力扣第314场周赛题解_2432. 处理用时最长的那个任务的员工

LeetCode 2432. 处理用时最长的那个任务的员工 

题目链接：6200. 处理用时最长的那个任务的员工 - 力扣（LeetCode）

解题思路：
直接找出他们工作差值的最大值然后记录id即可：

class Solution {
public:
    int hardestWorker(int n, vector<vector<int>>& logs) {
        int maxd = logs[0][1], id = logs[0][0];
        
        for (int i = 1; i < logs.size(); i ++ )
        {
            if ( maxd < logs[i][1] - logs[i - 1][1] || maxd == logs[i][1] - logs[i - 1][1] && id > logs[i][0])
            {
                maxd = logs[i][1] - logs[i - 1][1];
                id = logs[i][0];
            }
        }
        
        return id;
    }
};

LeetCode 2433. 找出前缀异或的原始数组

题目链接：

2433. 找出前缀异或的原始数组 - 力扣（LeetCode）

解题思路：

假设求出下表为前k的数，那么:

arr[0] = pref[0];

arr[1] = pref[1] ^ arr[0];

.....

arr[k] = pref[k] ^ arr[k - 1] ..... ^ arr[0]; 

可以看出对于计算arr[k]:   pref[k]和arr[0].....arr[k - 1]都是前面已经计算过的数，我们可以用一个前缀和s[i] = arr[0] ^ ......^ arr[i];

所以arr[i] = pref[i] ^ s[i - 1]

s[i] = arr[i] ^ s[i - 1] = pref[i] ^ s[i - 1] ^ s[i - 1] = pref[i];

class Solution {
public:
    vector<int> findArray(vector<int>& pref) {
        vector<int> ans;
        ans.push_back(pref[0]);
        int s[100010];
        s[0] = pref[0];
        for (int i = 1; i < pref.size(); i ++ )
        {
            ans.push_back(pref[i] ^ s[i - 1]);
            s[i] =  pref[i];
        }
        
        return ans;
    }
};

LeetCode 2434. 使用机器人打印字典序最小的字符串

题目链接：

Loading Question... - 力扣（LeetCode）

解题思路：

我们应该先把所有的a记录到答案res中，再把所有的b记录到答案res中以此类推：

我们先预处理一个数组pos，pos[s[i] - 'a'] = i， s[i]表示这个字母在s中最后一次出现的位置为 i 

从前往后枚举s，直到把s中所有的a全部枚举完，然后在s剩下的串中枚举b，判断t的末尾的字母是否 小于等于 b，若小于等于b则先把t末尾小于等于b的加入答案，然后再枚举剩下的s串中的字母，知道找到b字母出现的最后一个位置为止，以此类推：

const int N = 100010;
 
class Solution {
public:
    string robotWithString(string s) {
        string t, res;
        vector<int> pos(26, -1);
        
        for (int i = 0; i < s.size(); i ++ )
            pos[s[i] - 'a'] = i;//记录s[i]最后出现在s中的位置
        
        for (int i = 0, k = 0; i < 26 && k < s.size(); i ++ )//i为当前正在枚举的最小的字母
        {                                                    //k为s的下标
            char c = i + 'a';
            while (t.size() && t.back() <= c)//若t的末尾的字母小于当前正在枚举的字母
            {                                //则将末尾加入答案
                res += t.back();
                t.pop_back();
            }
            
            while (pos[i] >= k)//若字母s[i]出现的位置在k之后则一直循环
            {
                if (s[k] == i + 'a') res += s[k];//找到了目前最小的字母，加入答案
                else t += s[k];//否则加入t
                k ++ ;
            }
        }
        
        reverse(t.begin(), t.end());//每次t从最后一个取出作为答案，只需要令t反向即可
        return res + t;
    }

LeetCode 2435. 矩阵中和能被 K 整除的路径

题目链接：

6203. 矩阵中和能被 K 整除的路径 - 力扣（LeetCode）

解题思路：
定义一个三维数组f[i][j][k]：表示从(0, 0)走到(i, j)的余数为k的方案数为f[i][j][k];

则状态转移方程为：

f[i][j][(u + g[i][j]) % k] = (f[i - 1][j][u] + f[i][j - 1][u]) % mod;

class Solution {
public:
    int numberOfPaths(vector<vector<int>>& g, int k) {
        int n = g.size(), m = g[0].size(), mod = 1e9 + 7;
        vector<vector<vector<int>>> f(n + 1, vector<vector<int>>(m + 1, vector<int>(k)));
 
        f[1][1][g[0][0] % k] = 1;//i, j比g[i][j]多一位是为了防止判断边界
        for (int i = 1; i <= n; i ++ )
            for (int j = 1; j <= m; j ++ )
            {
                if (i == 1 && j == 1) continue;//已经被初始化过
                for (int u = 0; u < k; u ++ )//枚举从(0, 0)到(i, j)的所有余数
                {
                    f[i][j][(u + g[i - 1][j - 1]) % k] = (f[i - 1][j][u] + f[i][j - 1][u]) % mod;               
                }
            }
 
            return f[n][m][0];
    }
};