class Solution {
public:
int hardestWorker(int n, vector<vector<int>>& logs) {
}
};
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 按严格递增顺序排列原站题解
rust 解法, 执行用时: 4 ms, 内存消耗: 2 MB, 提交时间: 2023-09-13 15:52:41
impl Solution {
pub fn hardest_worker(n: i32, logs: Vec<Vec<i32>>) -> i32 {
let (mut ans, mut max_t) = (logs[0][0], logs[0][1]);
for i in 1..logs.len() {
let mut t = logs[i][1] - logs[i-1][1];
if ( t > max_t || t == max_t && logs[i][0] < ans ) {
ans = logs[i][0];
max_t = t;
}
}
ans
}
}
cpp 解法, 执行用时: 64 ms, 内存消耗: 35 MB, 提交时间: 2023-09-13 15:49:06
class Solution {
public:
int hardestWorker(int n, vector<vector<int>>& logs) {
int ans = logs[0][0], max_t = logs[0][1];
for (int i = 1; i < logs.size(); ++i) {
int t = logs[i][1] - logs[i-1][1];
if ( t > max_t || t == max_t && logs[i][0] < ans ) {
ans = logs[i][0];
max_t = t;
}
}
return ans;
}
};
java 解法, 执行用时: 1 ms, 内存消耗: 42.4 MB, 提交时间: 2023-09-13 15:48:36
class Solution {
public int hardestWorker(int n, int[][] logs) {
int ans = logs[0][0], max_t = logs[0][1];
for (int i = 1; i < logs.length; ++i) {
int t = logs[i][1] - logs[i-1][1];
if ( t > max_t || t == max_t && logs[i][0] < ans ) {
ans = logs[i][0];
max_t = t;
}
}
return ans;
}
}
golang 解法, 执行用时: 40 ms, 内存消耗: 6.8 MB, 提交时间: 2023-09-13 15:46:43
func hardestWorker(n int, logs [][]int) int {
ans, max_t := logs[0][0], logs[0][1]
for i := 1; i < len(logs); i++ {
t := logs[i][1] - logs[i-1][1]
if t > max_t || t == max_t && logs[i][0] < ans {
ans, max_t = logs[i][0], t
}
}
return ans
}
python3 解法, 执行用时: 40 ms, 内存消耗: 15 MB, 提交时间: 2022-10-13 09:30:02
class Solution:
def hardestWorker(self, n: int, logs: List[List[int]]) -> int:
ans, max_t = logs[0]
for (_, t1), (i, t) in pairwise(logs):
t -= t1
if t > max_t or t == max_t and i < ans:
ans, max_t = i, t
return ans