LeetCode 1094. 拼车

1094. 拼车

车上最初有 capacity 个空座位。车 只能 向一个方向行驶（也就是说，不允许掉头或改变方向）

给定整数 capacity 和一个数组 trips ,  trip[i] = [numPassengersi, fromi, toi] 表示第 i 次旅行有 numPassengersi 乘客，接他们和放他们的位置分别是 fromi 和 toi 。这些位置是从汽车的初始位置向东的公里数。

当且仅当你可以在所有给定的行程中接送所有乘客时，返回 true，否则请返回 false。

示例 1：

输入：trips = [[2,1,5],[3,3,7]], capacity = 4
输出：false

示例 2：

输入：trips = [[2,1,5],[3,3,7]], capacity = 5
输出：true

提示：

• 1 <= trips.length <= 1000
• trips[i].length == 3
• 1 <= numPassengersi <= 100
• 0 <= fromi < toi <= 1000
• 1 <= capacity <= 10^5

---

提示 1

Sort the pickup and dropoff events by location, then process them in order.

 

解法：差分数组

差分数组知识点：

代码模版：

Java版：

// 你有一个长为 n 的数组 a，一开始所有元素均为 0。
// 给定一些区间操作，其中 queries[i] = [left, right, x]，
// 你需要把子数组 a[left], a[left+1], ... a[right] 都加上 x。
// 返回所有操作执行完后的数组 a。
int[] solve(int n, int[][] queries) {
    int[] diff = new int[n]; // 差分数组
    for (int[] q : queries) {
        int left = q[0], right = q[1], x = q[2];
        diff[left] += x;
        if (right + 1 < n) {
            diff[right + 1] -= x;
        }
    }
    for (int i = 1; i < n; i++) {
        diff[i] += diff[i - 1]; // 直接在差分数组上复原数组 a
    }
    return diff;
}

Python版：

# 你有一个长为 n 的数组 a，一开始所有元素均为 0。
# 给定一些区间操作，其中 queries[i] = [left, right, x]，
# 你需要把子数组 a[left], a[left+1], ... a[right] 都加上 x。
# 返回所有操作执行完后的数组 a。
def solve(n: int, queries: List[List[int]]) -> List[int]:
    diff = [0] * n  # 差分数组
    for left, right, x in queries:
        diff[left] += x
        if right + 1 < n:
            diff[right + 1] -= x
    for i in range(1, n):
        diff[i] += diff[i - 1]  # 直接在差分数组上复原数组 a
    return diff

本题思路：

对于本题，设 a[i] 表示车行驶到位置 i 时车上的人数。我们需要判断是否所有 a[i] 都不超过 capacity。

trips[i] 相当于把 a 中下标从 from 到 to − 1 的数都增加 numPassengers 。这正好可以用差分数组解决。

例如示例 1 对应的 d 数组，d[1]=2, d[5]=−2, d[3]=3, d[7]=−3，即

d=[0,2,0,3,0,−2,0,−3,⋯]
从左到右累加，得到

a=[0,2,2,5,5,3,3,0,⋯]
capacity=4，由于 max(a)=5>4，所以返回 false。

trips[i] 中乘客的起点是from，终点是to，但是到位置 to 时，乘客下车，所以乘客在车上的路程是[from, to - 1]。

因此，我们只需要 2 次操作即可完成对差分数组 diff 的修改：将 diff[from i] 的值增加 num i，并将 diff[to i] 的值减少 num i。这样就可以将处理 trips i的时间复杂度减少至 O(1)。

我们可以预先对数组 trips 进行一次遍历，得到所有 to i 中的最大值 toMax(即路程的最远终点)，差分数组的最大下标只需要到 toMax。

Java版：

class Solution {
    public boolean carPooling(int[][] trips, int capacity) {
        int toMax = 0;
        for (int i = 0; i < trips.length; i++) {
            toMax = Math.max(toMax, trips[i][2]);
        }
        int[] diff = new int[toMax + 1];
        for (int i = 0; i < trips.length; i++) {
            int num = trips[i][0];
            int from = trips[i][1];
            int to = trips[i][2];
            diff[from] += num;
            diff[to] -= num;
        }
        for (int i = 0; i < toMax + 1; i++) {
            if (i > 0) {
                diff[i] += diff[i - 1];
            }
            if (diff[i] > capacity) {
                return false;
            } 
        }
        return true;
    } 
}

Python版：

class Solution:
    def carPooling(self, trips: List[List[int]], capacity: int) -> bool:
        toMax = 0
        n = len(trips)
        for trip in trips:
            toMax = max(toMax, trip[2])
        diff = [0] * (toMax + 1)
        for num, from_, to in trips:
            diff[from_] += num
            diff[to] -= num
        diff = accumulate(diff)
        return all(d <= capacity for d in diff)     

复杂度分析

• 时间复杂度：O(n+t)，其中 n 是数组 trips 的长度，t 是 toMax。
• 空间复杂度：O(t)，即为差分数组 diff 需要使用的空间。

 

以上解法参考 1094. 拼车 - 力扣（LeetCode） 分享｜【算法小课堂】差分数组（Python/Java/C++/Go/JS） - 力扣（LeetCode）