【LeetCode】1687. 从仓库到码头运输箱子

题目描述

你有一辆货运卡车，你需要用这一辆车把一些箱子从仓库运送到码头。这辆卡车每次运输有 箱子数目的限制 和 总重量的限制 。
给你一个箱子数组 boxes 和三个整数 portsCount, maxBoxes 和 maxWeight ，其中 boxes[i] = [ports​​_i, weight_i] 。
ports​​_i 表示第 i 个箱子需要送达的码头， weights_i 是第 i 个箱子的重量。
portsCount 是码头的数目。
maxBoxes 和 maxWeight 分别是卡车每趟运输箱子数目和重量的限制。
箱子需要按照 数组顺序 运输，同时每次运输需要遵循以下步骤：
卡车从 boxes 队列中按顺序取出若干个箱子，但不能违反 maxBoxes 和 maxWeight 限制。
对于在卡车上的箱子，我们需要 按顺序 处理它们，卡车会通过 一趟行程 将最前面的箱子送到目的地码头并卸货。如果卡车已经在对应的码头，那么不需要 额外行程 ，箱子也会立马被卸货。
卡车上所有箱子都被卸货后，卡车需要 一趟行程 回到仓库，从箱子队列里再取出一些箱子。
卡车在将所有箱子运输并卸货后，最后必须回到仓库。
请你返回将所有箱子送到相应码头的 最少行程 次数。

示例 1：

输入：boxes = [[1,1],[2,1],[1,1]], portsCount = 2, maxBoxes = 3, maxWeight = 3
输出：4
解释：最优策略如下：
卡车将所有箱子装上车，到达码头 1 ，然后去码头 2 ，然后再回到码头 1 ，最后回到仓库，总共需要 4 趟行程。
所以总行程数为 4 。
注意到第一个和第三个箱子不能同时被卸货，因为箱子需要按顺序处理（也就是第二个箱子需要先被送到码头 2 ，然后才能处理第三个箱子）。

示例 2：

输入：boxes = [[1,1],[2,1],[1,1]], portsCount = 2, maxBoxes = 3, maxWeight = 3
输出：4
解释：最优策略如下：
卡车将所有箱子装上车，到达码头 1 ，然后去码头 2 ，然后再回到码头 1 ，最后回到仓库，总共需要 4 趟行程。
所以总行程数为 4 。
注意到第一个和第三个箱子不能同时被卸货，因为箱子需要按顺序处理（也就是第二个箱子需要先被送到码头 2 ，然后才能处理第三个箱子）。
输入：boxes = [[1,2],[3,3],[3,1],[3,1],[2,4]], portsCount = 3, maxBoxes = 3, maxWeight = 6
输出：6
解释：最优策略如下：
卡车首先运输第一个箱子，到达码头 1 ，然后回到仓库，总共 2 趟行程。
卡车运输第二、第三、第四个箱子，到达码头 3 ，然后回到仓库，总共 2 趟行程。
卡车运输第五个箱子，到达码头 3 ，回到仓库，总共 2 趟行程。
总行程数为 2 + 2 + 2 = 6 。

示例 3：

输入：boxes = [[1,4],[1,2],[2,1],[2,1],[3,2],[3,4]], portsCount = 3, maxBoxes = 6, maxWeight = 7
输出：6
解释：最优策略如下：
卡车运输第一和第二个箱子，到达码头 1 ，然后回到仓库，总共 2 趟行程。
卡车运输第三和第四个箱子，到达码头 2 ，然后回到仓库，总共 2 趟行程。
卡车运输第五和第六个箱子，到达码头 3 ，然后回到仓库，总共 2 趟行程。
总行程数为 2 + 2 + 2 = 6 。

示例 4：

输入：boxes = [[2,4],[2,5],[3,1],[3,2],[3,7],[3,1],[4,4],[1,3],[5,2]], portsCount = 5, maxBoxes = 5, maxWeight = 7
输出：14
解释：最优策略如下：
卡车运输第一个箱子，到达码头 2 ，然后回到仓库，总共 2 趟行程。
卡车运输第二个箱子，到达码头 2 ，然后回到仓库，总共 2 趟行程。
卡车运输第三和第四个箱子，到达码头 3 ，然后回到仓库，总共 2 趟行程。
卡车运输第五个箱子，到达码头 3 ，然后回到仓库，总共 2 趟行程。
卡车运输第六和第七个箱子，到达码头 3 ，然后去码头 4 ，然后回到仓库，总共 3 趟行程。
卡车运输第八和第九个箱子，到达码头 1 ，然后去码头 5 ，然后回到仓库，总共 3 趟行程。
总行程数为 2 + 2 + 2 + 2 + 3 + 3 = 14 。

提示：

1 <= boxes.length <= 10⁵
1 <= portsCount, maxBoxes, maxWeight <= 10⁵
1 <= ports​​_i <= portsCount
1 <= weights_i <= maxWeight

方法一：朴素解法，会超时，需要优化

class Solution {
public:
    int boxDelivering(vector<vector<int>>& boxes, int portsCount, int maxBoxes, 
 int maxWeight) {
        int n = boxes.size();
        // 一开始将dp定义为无穷大
        vector<int> dp(n + 5, 0x3f3f3f3f);
        dp[0] = 0;

        // 遍历boxes数组,确定dp[i]
        for(int i=1; i<=n; i++){
            // sum:当前箱子总重量
            int sum = 0;
            // j表示当前考虑的箱子编号，从i开始考虑
            // 依次考虑:当前运送编号为j的箱子，编号为j-1到j的箱子...
            // 结束条件:包含第一个箱子，或者箱子数量已达上限
            for(int j=i; j>=1 && j>=i-maxBoxes+1; j--){
                // 更新当前箱子总重量
                // 代码中多次出现j-1,是因为boxes下标从0开始
                // dp[i]的i则表示第i个箱子,此时i和j-1相对应
                sum += boxes[j-1][1];
                // 如果当前箱子总重量超出上限，那么该情况及之后的情况都不考虑
                if(sum > maxWeight) break;
                // 否则比较该情况的dp[i]，并判断是否需要更新
                dp[i] = min(dp[i], dp[j-1] + cost(boxes, j, i));
            }
        }
        return dp[n];
    }
    int cost(vector<vector<int>>& boxes, int left, int right){
        // left:j, right:i
        // 因为需要按顺序运输，所以从编号为j考虑到编号为i

        // ans表示最短运输次数，只去一个码头最少需要2次
        // cost[i,i] = 2
        int ans = 2;
        // port:当前要去的码头
        int port = boxes[left-1][0];
        // 从箱子编号为left考虑到right
        while(++left <= right){
            // 如果下一个箱子仍然运到这个码头
            // 则不需要增加运输次数
            if(port == boxes[left-1][0]) continue;
            // 需要运送到新的码头，次数+1
            ans ++;
            // 更新当前码头
            port = boxes[left-1][0];
        }
        return ans;
    }

};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

方法二：时间优化

在这里插入代码片
1

心得
这道题能想到要用 动态规划，但是还是没办法解决。直接看题解了，作者是一步步实现的，首先给出「朴素方法」，能通过大多数的点，但是对于最后 4 个测试点会超时，因此方法二和方法三分别从「时间」和「空间」进行优化，方法四则使用了「优先队列」。

方法一：朴素方法：动态规划

• 思路

  • 简单抽象出一个状态集合， dp[i] 即运送前 i 个箱子需要的最小行程次数，因此该题的答案就是 f[n]
  • 那么如何进行状态计算呢？
    通过枚举最后一次运送的状态，包括[1,2,3…,maxBoxes] 的箱子，比较确定运输这些箱子的最小次数。
    dp[ i ] = dp[ j-1 ] + cost[ j , i ] ，( i - maxB + 1 <= j <= i )
    cost[ j , i ] ：运输第k~i个箱子的行程次数

• 时间复杂度： O（n³）

• 空间复杂度： O（n）

• 显然，这个方法的时间复杂度太高了，只能通过 35/39 的测试点，因此需要优化。

参考资料

1. C++容器详解之deque
2. 四种方法，由深入浅，java实现
3. [Python3/Java/C++/Go] 一题一解：动态规划 + 单调队列（清晰题解）