1
2
3
4
5
6
7
8
| 输入：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 。
|
突发奇想，想练习一下sort方法的运用熟练程度
1
2
3
4
5
6
7
8
9
10
11
12
13
| class Solution {
public int hardestWorker(int n, int[][] logs) {
for(int i=logs.length-1;i>=0;i--){
if(i==0) break;
else logs[i][1]-=logs[i-1][1];
}
Arrays.sort(logs,(a,b)->{
if(b[1]!=a[1])return b[1]-a[1];
else return a[0]-b[0];
});
return logs[0][0];
}
}
|
1
2
3
4
5
6
7
8
| 输入：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
|
寻找数学规律即可，只不过确实需要自己写例子推导一下
1
2
3
4
5
6
7
8
9
10
11
12
13
| class Solution {
public int[] findArray(int[] pref) {
int n = pref.length;
int[] res = new int[n];
if(n<=1) return pref;
res[0] = pref[0];
for(int i=0,p=1;i<n-1&&p<n;i++){
int j = i+1;
res[p++] = pref[i]^pref[j];
}
return res;
}
}
|
1
2
3
4
| 给你一个下标从 0 开始的 m x n 整数矩阵 grid 和一个整数 k
你从起点 (0, 0) 出发，每一步只能往下或者往右 ，你想要到达终点 (m - 1, n - 1) 。
请你返回路径和能被 k 整除的路径数目，由于答案可能很大，返回答案对 109 + 7 取余 的结果。
|
我刚开始觉得应该是回溯，因为是图的路径问题，但是有几个用例总是无法通过
最后看解析才发现需要使用DP，确实有点难，特别是状态转换方程的推导
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
| class Solution {
public int numberOfPaths(int[][] grid, int k) {
int m = grid.length;
int n = grid[0].length;
int[][][] c = new int[m][n][k];
c[0][0][grid[0][0]%k]++;
for(int i=1; i<m; i++){
for(int l = 0; l<k; l++){
c[i][0][(l+grid[i][0])%k] += c[i-1][0][l];
}
}
for(int j=1; j<n; j++){
for(int l = 0; l<k; l++){
c[0][j][(l+grid[0][j])%k] += c[0][j-1][l];
}
}
for(int i=1; i<m; i++){
for(int j=1; j<n; j++){
for(int l = 0; l<k; l++){
c[i][j][(l+grid[i][j])%k] += c[i-1][j][l];
c[i][j][(l+grid[i][j])%k] += c[i][j-1][l];
}
for(int l = 0; l<k; l++){
if(c[i][j][l] >= 1000000007) c[i][j][l] -=1000000007 ;
}
}
}
return c[m-1][n-1][0];
}
}
|