共有 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 按严格递增顺序排列
方法一：枚举每一位员工
思路与算法
我们可以对数组 logs 进行一次遍历，算出其中每位员工的处理用时并得到答案。
具体地，我们在遍历时维护两个变量 maxcost 和 ans，前者表示最长的处理用时，后者表示其对应的员工。首个任务从时刻 0 开始，因此初始时，我们将这两个变量赋值为 logs}[0] 中的两个值。随后我们从 logs}[1] 开始遍历，通过相邻两项的差值计算出处理用时，并根据题目的要求对于 maxcost 和 ans 进行更新即可。
代码
[sol1-C++]1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| class Solution {
public:
int hardestWorker(int n, vector<vector<int>>& logs) {
int ans = logs[0][0], maxcost = logs[0][1];
for (int i = 1; i < logs.size(); ++i) {
int idx = logs[i][0];
int cost = logs[i][1] - logs[i - 1][1];
if (cost > maxcost || (cost == maxcost && idx < ans)) {
ans = idx;
maxcost = cost;
}
}
return ans;
}
};
|
[sol1-Java]1
2
3
4
5
6
7
8
9
10
11
12
13
14
| class Solution {
public int hardestWorker(int n, int[][] logs) {
int ans = logs[0][0], maxcost = logs[0][1];
for (int i = 1; i < logs.length; ++i) {
int idx = logs[i][0];
int cost = logs[i][1] - logs[i - 1][1];
if (cost > maxcost || (cost == maxcost && idx < ans)) {
ans = idx;
maxcost = cost;
}
}
return ans;
}
}
|
[sol1-C#]1
2
3
4
5
6
7
8
9
10
11
12
13
14
| public class Solution {
public int HardestWorker(int n, int[][] logs) {
int ans = logs[0][0], maxcost = logs[0][1];
for (int i = 1; i < logs.Length; ++i) {
int idx = logs[i][0];
int cost = logs[i][1] - logs[i - 1][1];
if (cost > maxcost || (cost == maxcost && idx < ans)) {
ans = idx;
maxcost = cost;
}
}
return ans;
}
}
|
[sol1-Python3]1
2
3
4
5
6
7
8
| class Solution:
def hardestWorker(self, n: int, logs: List[List[int]]) -> int:
ans, maxcost = logs[0]
for i in range(1, len(logs)):
idx, cost = logs[i][0], logs[i][1] - logs[i - 1][1]
if cost > maxcost or (cost == maxcost and idx < ans):
ans, maxcost = idx, cost
return ans
|
[sol1-Go]1
2
3
4
5
6
7
8
9
10
11
12
| func hardestWorker(n int, logs [][]int) int {
ans, maxCost := logs[0][0], logs[0][1]
for i := 1; i < len(logs); i++ {
idx := logs[i][0]
cost := logs[i][1] - logs[i - 1][1]
if cost > maxCost || (cost == maxCost && idx < ans) {
ans = idx
maxCost = cost
}
}
return ans
}
|
[sol1-JavaScript]1
2
3
4
5
6
7
8
9
10
11
12
| var hardestWorker = function(n, logs) {
let ans = logs[0][0], maxCost = logs[0][1];
for (let i = 1; i < logs.length; i++) {
const idx = logs[i][0];
const cost = logs[i][1] - logs[i - 1][1];
if (cost > maxCost || (cost === maxCost && idx < ans)) {
ans = idx;
maxCost = cost;
}
}
return ans;
};
|
[sol1-C]1
2
3
4
5
6
7
8
9
10
11
12
| int hardestWorker(int n, int** logs, int logsSize, int* logsColSize) {
int ans = logs[0][0], maxcost = logs[0][1];
for (int i = 1; i < logsSize; ++i) {
int idx = logs[i][0];
int cost = logs[i][1] - logs[i - 1][1];
if (cost > maxcost || (cost == maxcost && idx < ans)) {
ans = idx;
maxcost = cost;
}
}
return ans;
}
|
复杂度分析
