跳转至

3683. 完成一个任务的最早时间

题目描述

给你一个二维整数数组 tasks，其中 tasks[i] = [si, ti]。

数组中的每个 [si, ti] 表示一个任务，该任务的开始时间为 si，完成该任务需要 ti 个时间单位。

返回至少完成一个任务的最早时间。

 

示例 1：

输入： tasks = [[1,6],[2,3]]

输出： 5

解释：

第一个任务从时间 t = 1 开始，并在 1 + 6 = 7 时完成。第二个任务在时间 t = 2 开始，并在 2 + 3 = 5 时完成。因此，最早完成的任务在时间 5。

示例 2：

输入： tasks = [[100,100],[100,100],[100,100]]

输出： 200

解释：

三个任务都在时间 100 + 100 = 200 时完成。

 

提示：

  • 1 <= tasks.length <= 100
  • tasks[i] = [si, ti]
  • 1 <= si, ti <= 100

解法

方法一：一次遍历

我们遍历 \(\textit{tasks}\) 数组，对于每个任务，计算其完成时间 \(s_i + t_i\)，求出所有任务完成时间的最小值，即为至少完成一个任务的最早时间。

时间复杂度 \(O(n)\)，其中 \(n\) 为 \(\textit{tasks}\) 数组的长度。空间复杂度 \(O(1)\)。

1
2
3
class Solution:
    def earliestTime(self, tasks: List[List[int]]) -> int:
        return min(s + t for s, t in tasks)

1
2
3
4
5
6
7
8
9
class Solution {
    public int earliestTime(int[][] tasks) {
        int ans = 200;
        for (var task : tasks) {
            ans = Math.min(ans, task[0] + task[1]);
        }
        return ans;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
class Solution {
public:
    int earliestTime(vector<vector<int>>& tasks) {
        int ans = 200;
        for (const auto& task : tasks) {
            ans = min(ans, task[0] + task[1]);
        }
        return ans;
    }
};

1
2
3
4
5
6
7
func earliestTime(tasks [][]int) int {
    ans := 200
    for _, task := range tasks {
        ans = min(ans, task[0]+task[1])
    }
    return ans
}

1
2
3
function earliestTime(tasks: number[][]): number {
    return Math.min(...tasks.map(task => task[0] + task[1]));
}

评论