feat: leetcode 1687

Author: deweyou

README.md

@@ -2,7 +2,7 @@
 
 <p align="center">
 <!-- TOPICS COUNT START -->
-<img src="https://img.shields.io/badge/-进度:562-green" alt="进度:562">
+<img src="https://img.shields.io/badge/-进度:563-green" alt="进度:563">
 <!-- TOPICS COUNT END -->
 <a href="./assets/docs/TOPICS.md"><img src="https://img.shields.io/badge/-题库目录-blue" alt="题库目录"></a>
 <a href="./assets/docs/CATEGORIES.md"><img src="https://img.shields.io/badge/-题库分类-red" alt="题库分类"></a>

assets/data/categories.json

@@ -1777,6 +1777,12 @@
         "path": "./problemset/maximum-repeating-substring/README.md",
         "difficulty": "简单"
       },
+      {
+        "id": "1687",
+        "title": "从仓库到码头运输箱子",
+        "path": "./problemset/delivering-boxes-from-storage-to-ports/README.md",
+        "difficulty": "困难"
+      },
       {
         "id": "1774",
         "title": "最接近目标价格的甜点成本",

assets/data/topics.json

@@ -5069,6 +5069,16 @@
     "url": "https://leetcode.cn/problems/count-the-number-of-consistent-strings/",
     "path": "./problemset/count-the-number-of-consistent-strings/README.md"
   },
+  {
+    "id": "1687",
+    "title": {
+      "cn": "从仓库到码头运输箱子",
+      "en": "delivering-boxes-from-storage-to-ports"
+    },
+    "difficulty": "困难",
+    "url": "https://leetcode.cn/problems/delivering-boxes-from-storage-to-ports/",
+    "path": "./problemset/delivering-boxes-from-storage-to-ports/README.md"
+  },
   {
     "id": "1694",
     "title": {

assets/docs/CATEGORIES.md

@@ -329,6 +329,7 @@
 | 940. [不同的子序列 II](../../problemset/distinct-subsequences-2/README.md) | 困难 |
 | 1235. [规划兼职工作](../../problemset/maximum-profit-in-job-scheduling/README.md) | 困难 |
 | 1668. [最大重复子字符串](../../problemset/maximum-repeating-substring/README.md) | 简单 |
+| 1687. [从仓库到码头运输箱子](../../problemset/delivering-boxes-from-storage-to-ports/README.md) | 困难 |
 | 1774. [最接近目标价格的甜点成本](../../problemset/closest-dessert-cost/README.md) | 中等 |
 | 1800. [最大升序子数组和](../../problemset/maximum-ascending-subarray-sum/README.md) | 简单 |
 | 1994. [好子集的数目](../../problemset/the-number-of-good-subsets/README.md) | 困难 |

assets/docs/TOPICS.md

@@ -1014,6 +1014,8 @@
 
 [1684. 统计一致字符串的数目](../../problemset/count-the-number-of-consistent-strings/README.md)
 
+[1687. 从仓库到码头运输箱子](../../problemset/delivering-boxes-from-storage-to-ports/README.md)
+
 [1694. 重新格式化电话号码](../../problemset/reformat-phone-number/README.md)
 
 [1700. 无法吃午餐的学生数量](../../problemset/number-of-students-unable-to-eat-lunch/README.md)

problemset/delivering-boxes-from-storage-to-ports/README.md

@@ -0,0 +1,125 @@
+# 从仓库到码头运输箱子
+
+> 难度：困难
+>
+> https://leetcode.cn/problems/delivering-boxes-from-storage-to-ports/
+
+## 题目
+
+你有一辆货运卡车，你需要用这一辆车把一些箱子从仓库运送到码头。这辆卡车每次运输有 **箱子数目的限制** 和 **总重量的限制** 。
+
+给你一个箱子数组 `boxes` 和三个整数 `portsCount`, `maxBoxes` 和 `maxWeight` ，其中 `boxes[i] = [ports​​i​, weighti]` 。
+
+- `ports​​i` 表示第 `i` 个箱子需要送达的码头， `weightsi` 是第 `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,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 。
+```
+
+## 解题
+
+```ts 
+/**
+ * 动态规划 + 单调队列优化
+ * @desc 时间复杂度 O(n) 空间复杂度 O(n)
+ * @param boxes
+ * @param portsCount
+ * @param maxBoxes
+ * @param maxWeight
+ * @returns
+ */
+export function boxDelivering(boxes: number[][], portsCount: number, maxBoxes: number, maxWeight: number): number {
+  const n = boxes.length
+  const p = new Array(n + 1).fill(0)
+  const w = new Array(n + 1).fill(0)
+  const neg = new Array(n + 1).fill(0)
+  const W = new Array(n + 1).fill(0)
+  for (let i = 1; i <= n; ++i) {
+    p[i] = boxes[i - 1][0]
+    w[i] = boxes[i - 1][1]
+    if (i > 1)
+      neg[i] = neg[i - 1] + (p[i - 1] !== p[i] ? 1 : 0)
+
+    W[i] = W[i - 1] + w[i]
+  }
+
+  const opt = [0]
+  const f = new Array(n + 1).fill(0)
+  const g = new Array(n + 1).fill(0)
+  for (let i = 1; i <= n; ++i) {
+    while (i - opt[0] > maxBoxes || W[i] - W[opt[0]] > maxWeight)
+      opt.shift()
+
+    f[i] = g[opt[0]] + neg[i] + 2
+
+    if (i !== n) {
+      g[i] = f[i] - neg[i + 1]
+      while (opt.length && g[i] <= g[opt[opt.length - 1]])
+        opt.pop()
+
+      opt.push(i)
+    }
+  }
+
+  return f[n]
+}
+```

problemset/delivering-boxes-from-storage-to-ports/index.spec.ts

@@ -0,0 +1,18 @@
+import { describe, expect, it } from 'vitest'
+import { boxDelivering } from '.'
+
+describe('从仓库到码头运输箱子', () => {
+  testCase(boxDelivering)
+})
+
+function testCase(fn: (boxes: number[][], portsCount: number, maxBoxes: number, maxWeight: number) => number) {
+  it.each([
+    [[[1, 1], [2, 1], [1, 1]], 2, 3, 3, 4],
+    [[[1, 2], [3, 3], [3, 1], [3, 1], [2, 4]], 3, 3, 6, 6],
+    [[[1, 4], [1, 2], [2, 1], [2, 1], [3, 2], [3, 4]], 3, 6, 7, 6],
+    [[[2, 4], [2, 5], [3, 1], [3, 2], [3, 7], [3, 1], [4, 4], [1, 3], [5, 2]], 5, 5, 7, 14],
+
+  ])('示例%#', (boxes, portsCount, maxBoxes, maxWeight, expected) => {
+    expect(fn(boxes, portsCount, maxBoxes, maxWeight)).toBe(expected)
+  })
+}

problemset/delivering-boxes-from-storage-to-ports/index.ts

@@ -0,0 +1,44 @@
+/**
+ * 动态规划 + 单调队列优化
+ * @desc 时间复杂度 O(n) 空间复杂度 O(n)
+ * @param boxes
+ * @param portsCount
+ * @param maxBoxes
+ * @param maxWeight
+ * @returns
+ */
+export function boxDelivering(boxes: number[][], portsCount: number, maxBoxes: number, maxWeight: number): number {
+  const n = boxes.length
+  const p = new Array(n + 1).fill(0)
+  const w = new Array(n + 1).fill(0)
+  const neg = new Array(n + 1).fill(0)
+  const W = new Array(n + 1).fill(0)
+  for (let i = 1; i <= n; ++i) {
+    p[i] = boxes[i - 1][0]
+    w[i] = boxes[i - 1][1]
+    if (i > 1)
+      neg[i] = neg[i - 1] + (p[i - 1] !== p[i] ? 1 : 0)
+
+    W[i] = W[i - 1] + w[i]
+  }
+
+  const opt = [0]
+  const f = new Array(n + 1).fill(0)
+  const g = new Array(n + 1).fill(0)
+  for (let i = 1; i <= n; ++i) {
+    while (i - opt[0] > maxBoxes || W[i] - W[opt[0]] > maxWeight)
+      opt.shift()
+
+    f[i] = g[opt[0]] + neg[i] + 2
+
+    if (i !== n) {
+      g[i] = f[i] - neg[i + 1]
+      while (opt.length && g[i] <= g[opt[opt.length - 1]])
+        opt.pop()
+
+      opt.push(i)
+    }
+  }
+
+  return f[n]
+}