How do I handle the first task when calculating durations?

Use 0 as the previous time to compute the duration of the first task as leaveTime[0] minus 0.

What if multiple employees share the longest task duration?

Return the employee with the smallest ID to resolve ties, as required by the problem.

Does the array need sorting before processing?

No, the logs are strictly increasing by leaveTime, so direct iteration is sufficient.

What is the time complexity for this array-driven solution?

It is O(m), where m is the number of tasks in logs, because each log entry is processed once.

Can GhostInterview explain why the Array-driven solution works for this problem?

Yes, it emphasizes sequentially computing task durations and updating the maximum efficiently using the array pattern.

#2432

Easy

auto_awesome数组·driven

LeetCode 题解工作台

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

共有 n 位员工，每位员工都有一个从 0 到 n - 1 的唯一 id 。给你一个二维整数数组 logs ，其中 logs[i] = [id i , leaveTime i ] ： id i 是处理第 i 个任务的员工的 id ，且 leaveTime i 是员工完成第 i 个任务的时刻。所有 l…

数组

题目描述

共有 n 位员工，每位员工都有一个从 0 到 n - 1 的唯一 id 。

给你一个二维整数数组 logs ，其中 logs[i] = [id_i, leaveTime_i] ：

id_i 是处理第 i 个任务的员工的 id ，且
leaveTime_i 是员工完成第 i 个任务的时刻。所有 leaveTime_i 的值都是唯一的。

注意，第 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 <= 500
1 <= logs.length <= 500
logs[i].length == 2
0 <= id_i <= n - 1
1 <= leaveTime_i <= 500
id_i != id_{i + 1}
leaveTime_i 按严格递增顺序排列

lightbulb

解题思路

方法一：直接遍历

我们用变量 $last$ 记录上一个任务的结束时间，用变量 $mx$ 记录最长的工作时间，用变量 $ans$ 记录工作时间最长且 $id$ 最小的员工。初始时，三个变量均为 $0$ 。

接下来，遍历数组 $logs$ ，对于每个员工，我们将员工完成任务的时间减去上一个任务的结束时间，即可得到该员工的工作时间 $t$ 。如果 $mx$ 小于 $t$ ，或者 $mx$ 等于 $t$ 且该员工的 $id$ 小于 $ans$ ，则更新 $mx$ 和 $ans$ 。然后我们将 $last$ 更新为上一个任务的结束时间加上 $t$ 。继续遍历，直到遍历完整个数组。

最后返回答案 $ans$ 即可。

时间复杂度 $O(n)$ ，其中 $n$ 为数组 $logs$ 的长度。空间复杂度 $O(1)$ 。

1

2

3

4

5

6

7

8

9

10

class Solution:
    def hardestWorker(self, n: int, logs: List[List[int]]) -> int:
        last = mx = ans = 0
        for uid, t in logs:
            t -= last
            if mx < t or (mx == t and ans > uid):
                ans, mx = uid, t
            last += t
        return ans

speed

复杂度分析

指标	值
时间	complexity is O(m) where m is the number of tasks in logs since we iterate once through the array. Space complexity is O(1) because we only maintain a few variables regardless of input size.
空间	Depends on the final approach

psychology

面试官常问的追问

外企场景

question_mark
Expect array-driven calculations without sorting logs again.
question_mark
Check for tie-breaking using the smallest employee ID for identical durations.
question_mark
Ensure edge cases handle the first task starting at time 0 correctly.

warning

常见陷阱

外企场景

error
Forgetting that the first task duration is just leaveTime[0] minus 0.
error
Not handling ties correctly when multiple employees have the same longest task.
error
Using previous employee IDs incorrectly instead of comparing task durations properly.

swap_horiz

进阶变体

外企场景

arrow_right_alt
Find the employee with the shortest task instead of the longest using the same array approach.
arrow_right_alt
Return all employees tied for the longest task as a list, sorted by ID.
arrow_right_alt
Given logs are unsorted, first sort by leaveTime before applying the same array-driven method.

help

常见问题

外企场景

继续练习

#2433 找出前缀异或的原始数组 #2435 矩阵中和能被 K 整除的路径 #2428 沙漏的最大总和