2432. 处理用时最长的那个任务的员工
共有 n 位员工，每位员工都有一个从 0 到 n - 1 的唯一 id 。
给你一个二维整数数组 logs ，其中 logs[i] = [idi, leaveTimei] ：
idi是处理第i个任务的员工的 id ，且leaveTimei是员工完成第i个任务的时刻。所有leaveTimei的值都是 唯一 的。
注意，第 i 个任务在第 (i - 1) 个任务结束后立即开始，且第 0 个任务从时刻 0 开始。
返回处理用时最长的那个任务的员工的 id 。如果存在两个或多个员工同时满足，则返回几人中 最小 的 id 。
示例 1：
输入： n = 10, logs = [[0,3],[2,5],[0,9],[1,15]]
输出： 1
解释：
任务 0 于时刻 0 开始，且在时刻 3 结束，共计 3 个单位时间。
任务 1 于时刻 3 开始，且在时刻 5 结束，共计 2 个单位时间。
任务 2 于时刻 5 开始，且在时刻 9 结束，共计 4 个单位时间。
任务 3 于时刻 9 开始，且在时刻 15 结束，共计 6 个单位时间。
时间最长的任务是任务 3 ，而 id 为 1 的员工是处理此任务的员工，所以返回 1 。
示例 2：
输入： n = 26, logs = [[1,1],[3,7],[2,12],[7,17]]
输出： 3
解释：
任务 0 于时刻 0 开始，且在时刻 1 结束，共计 1 个单位时间。
任务 1 于时刻 1 开始，且在时刻 7 结束，共计 6 个单位时间。
任务 2 于时刻 7 开始，且在时刻 12 结束，共计 5 个单位时间。
任务 3 于时刻 12 开始，且在时刻 17 结束，共计 5 个单位时间。
时间最长的任务是任务 1 ，而 id 为 3 的员工是处理此任务的员工，所以返回 3 。
示例 3：
输入： n = 2, logs = [[0,10],[1,20]]
输出： 0
解释：
任务 0 于时刻 0 开始，且在时刻 10 结束，共计 10 个单位时间。
任务 1 于时刻 10 开始，且在时刻 20 结束，共计 10 个单位时间。
时间最长的任务是任务 0 和 1 ，处理这两个任务的员工的 id 分别是 0 和 1 ，所以返回最小的 0 。
提示：
2 <= n <= 5001 <= logs.length <= 500logs[i].length == 20 <= idi <= n - 11 <= leaveTimei <= 500idi != idi + 1leaveTimei按严格递增顺序排列
题解: 模拟
class Solution {
public:
int hardestWorker(int n, vector<vector<int>>& logs) {
int pre = 0;
int maxv = -1, index = INT_MAX;
for(auto c : logs){
if(c[1] - pre > maxv){
maxv = c[1] - pre;
index = c[0];
}else if(c[1] - pre == maxv){
index = min(index, c[0]);
}
pre = c[1];
}
return index;
}
};
2433. 找出前缀异或的原始数组
给你一个长度为 n 的 整数 数组 pref 。找出并返回满足下述条件且长度为 n 的数组 arr ：
pref[i] = arr[0] ^ arr[1] ^ ... ^ arr[i]. 注意 ^ 表示 按位异或（bitwise-xor）运算。
可以证明答案是 唯一 的。
示例 1：
输入：pref = [5,2,0,3,1] 输出：[5,7,2,3,2] 解释：从数组 [5,7,2,3,2] 可以得到如下结果：
- pref[0] = 5
- pref[1] = 5 ^ 7 = 2
- pref[2] = 5 ^ 7 ^ 2 = 0
- pref[3] = 5 ^ 7 ^ 2 ^ 3 = 3
- pref[4] = 5 ^ 7 ^ 2 ^ 3 ^ 2 = 1 示例 2：
输入：pref = [13] 输出：[13] 解释：pref[0] = arr[0] = 13
提示：
1 <= pref.length <= 105 0 <= pref[i] <= 106
题解： 类似前缀和， 异或运算 a^b=c, b=a^c
class Solution {
public:
vector<int> findArray(vector<int>& pref) {
int n = pref.size();
vector<int> res(n);
res[0] = pref[0];
int s = res[0];
for(int i=1; i<n; i++){
res[i] = s ^ pref[i];
s = s ^ res[i];
}
return res;
}
};
2434. 使用机器人打印字典序最小的字符串
给你一个字符串 s 和一个机器人，机器人当前有一个空字符串 t 。执行以下操作之一，直到 s 和 t 都变成空字符串：
删除字符串 s 的 第一个 字符，并将该字符给机器人。机器人把这个字符添加到 t 的尾部。 删除字符串 t 的 最后一个 字符，并将该字符给机器人。机器人将该字符写到纸上。 请你返回纸上能写出的字典序最小的字符串。
示例 1：
输入：s = "zza"
输出："azz"
解释：用 p 表示写出来的字符串。
一开始，p="" ，s="zza" ，t="" 。
执行第一个操作三次，得到 p="" ，s="" ，t="zza" 。
执行第二个操作三次，得到 p="azz" ，s="" ，t="" 。
示例 2：
输入：s = "bac"
输出："abc"
解释：用 p 表示写出来的字符串。
执行第一个操作两次，得到 p="" ，s="c" ，t="ba" 。
执行第二个操作两次，得到 p="ab" ，s="c" ，t="" 。
执行第一个操作，得到 p="ab" ，s="" ，t="c" 。
执行第二个操作，得到 p="abc" ，s="" ，t="" 。
示例 3：
输入：s = "bdda"
输出："addb"
解释：用 p 表示写出来的字符串。
一开始，p="" ，s="bdda" ，t="" 。
执行第一个操作四次，得到 p="" ，s="" ，t="bdda" 。
执行第二个操作四次，得到 p="addb" ，s="" ，t="" 。
提示：
1 <= s.length <= 105
s 只包含小写英文字母。
题解：贪心算法
class Solution {
public:
string robotWithString(string s) {
int n = s.size();
vector<char> f(n+1);
f[n] = 'z' + 1;
// 右边最小值
for(int i=n-1; i>=0; i--){
f[i] = min(f[i+1], s[i]);
}
string res;
stack<char> st;
for(int i=0; i<n; i++){
st.push(s[i]);
// 小于最小值，弹出
while(!st.empty() && st.top() <= f[i+1]){
res.push_back(st.top());
st.pop();
}
}
return res;
}
};
2435. 矩阵中和能被 K 整除的路径
给你一个下标从 0 开始的 m x n 整数矩阵 grid 和一个整数 k 。你从起点 (0, 0) 出发，每一步只能往 下 或者往 右 ，你想要到达终点 (m - 1, n - 1) 。
请你返回路径和能被 k 整除的路径数目，由于答案可能很大，返回答案对 109 + 7 取余 的结果。
示例 1：
输入： grid = [[5,2,4],[3,0,5],[0,7,2]], k = 3
输出： 2
解释： 有两条路径满足路径上元素的和能被 k 整除。
第一条路径为上图中用红色标注的路径，和为 5 + 2 + 4 + 5 + 2 = 18 ，能被 3 整除。
第二条路径为上图中用蓝色标注的路径，和为 5 + 3 + 0 + 5 + 2 = 15 ，能被 3 整除。
示例 2：
输入： grid = [[0,0]], k = 5
输出： 1
解释： 红色标注的路径和为 0 + 0 = 0 ，能被 5 整除。
示例 3：
输入： grid = [[7,3,4,9],[2,3,6,2],[2,3,7,0]], k = 1
输出： 10
解释： 每个数字都能被 1 整除，所以每一条路径的和都能被 k 整除。
提示：
m == grid.lengthn == grid[i].length1 <= m, n <= 5 * 1041 <= m * n <= 5 * 1040 <= grid[i][j] <= 1001 <= k <= 50
题解：动态规划
const int MOD = 1e9+7;
class Solution {
public:
int numberOfPaths(vector<vector<int>>& grid, int k) {
int n = grid.size(), m = grid[0].size();
long long f[n][m][k]; // 到达(i, j) 余数为 k 的个数。
memset(f, 0, sizeof f);
f[0][0][grid[0][0]%k] = 1;
for(int i=0; i<n; i++){
for(int j=0; j<m; j++){
for(int t = 0; t<k; t++){
if(i >0){
f[i][j][t] = (f[i][j][t] + f[i-1][j][(t-grid[i][j]%k+k)%k])%MOD;
}
if(j > 0){
f[i][j][t] = (f[i][j][t] + f[i][j-1][(t-grid[i][j]%k+k)%k])%MOD;
}
}
}
}
return f[n-1][m-1][0];
}
};
