代码如诗

100097. 合法分组的最少组数

给你一个长度为 n 下标从 0 开始的整数数组 nums 。

我们想将下标进行分组，使得 [0, n - 1] 内所有下标 i 都 恰好 被分到其中一组。

如果以下条件成立，我们说这个分组方案是合法的：

• 对于每个组 g ，同一组内所有下标在 nums 中对应的数值都相等。

• 对于任意两个组 g1 和 g2 ，两个组中 下标数量 的 差值不超过 1 。

请你返回一个整数，表示得到一个合法分组方案的 最少 组数。

示例 1：

```txt

输入：nums = [3,2,3,2,3]

输出：2

解释：一个得到 2 个分组的方案如下，中括号内的数字都是下标：

组 1 -> [0,2,4]

组 2 -> [1,3]

所有下标都只属于一个组。

组 1 中，nums[0] == nums[2] == nums[4] ，所有下标对应的数值都相等。

组 2 中，nums[1] == nums[3] ，所有下标对应的数值都相等。

组 1 中下标数目为 3 ，组 2 中下标数目为 2 。

两者之差不超过 1 。

无法得到一个小于 2 组的答案，因为如果只有 1 组，组内所有下标对应的数值都要相等。

所以答案为 2 。

```

示例 2：

```txt

输入：nums = [10,10,10,3,1,1]

输出：4

解释：一个得到 2 个分组的方案如下，中括号内的数字都是下标：

组 1 -> [0]

组 2 -> [1,2]

组 3 -> [3]

组 4 -> [4,5]

分组方案满足题目要求的两个条件。

无法得到一个小于 4 组的答案。

所以答案为 4 。

```

提示：

• 1 <= nums.length <= 10^5

• 1 <= nums[i] <= 10^9

2850. 将石头分散到网格图的最少移动次数

给你一个大小为 3 * 3 ，下标从 0 开始的二维整数矩阵 grid ，分别表示每一个格子里石头的数目。网格图中总共恰好有 9 个石头，一个格子里可能会有 多个 石头。

每一次操作中，你可以将一个石头从它当前所在格子移动到一个至少有一条公共边的相邻格子。

请你返回每个格子恰好有一个石头的 最少移动次数 。

示例 1：

```txt

输入：grid = [[1,1,0],[1,1,1],[1,2,1]]

输出：3

解释：让每个格子都有一个石头的一个操作序列为：

1 - 将一个石头从格子 (2,1) 移动到 (2,2) 。

2 - 将一个石头从格子 (2,2) 移动到 (1,2) 。

3 - 将一个石头从格子 (1,2) 移动到 (0,2) 。

总共需要 3 次操作让每个格子都有一个石头。

让每个格子都有一个石头的最少操作次数为 3 。

```

示例 2：

```txt

输入：grid = [[1,3,0],[1,0,0],[1,0,3]]

输出：4

解释：让每个格子都有一个石头的一个操作序列为：

1 - 将一个石头从格子 (0,1) 移动到 (0,2) 。

2 - 将一个石头从格子 (0,1) 移动到 (1,1) 。

3 - 将一个石头从格子 (2,2) 移动到 (1,2) 。

4 - 将一个石头从格子 (2,2) 移动到 (2,1) 。

总共需要 4 次操作让每个格子都有一个石头。

让每个格子都有一个石头的最少操作次数为 4 。

```

提示：

• grid.length == grid[i].length == 3

• 0 <= grid[i][j] <= 9

• grid 中元素之和为 9 。

2699. 修改图中的边权

给你一个 n 个节点的 无向带权连通 图，节点编号为 0 到 n - 1 ，再给你一个整数数组 edges ，其中 edges[i] = [ai, bi, wi] 表示节点 ai 和 bi 之间有一条边权为 wi 的边。

部分边的边权为 -1（wi = -1），其他边的边权都为 正 数（wi > 0）。

你需要将所有边权为 -1 的边都修改为范围 [1, 2 * 10^9] 中的 正整数 ，使得从节点 source 到节点 destination 的 最短距离 为整数 target 。如果有 多种 修改方案可以使 source 和 destination 之间的最短距离等于 target ，你可以返回任意一种方案。

如果存在使 source 到 destination 最短距离为 target 的方案，请你按任意顺序返回包含所有边的数组（包括未修改边权的边）。如果不存在这样的方案，请你返回一个 空数组 。

注意：你不能修改一开始边权为正数的边。

示例 1：

```txt

输入：n = 5, edges = [[4,1,-1],[2,0,-1],[0,3,-1],[4,3,-1]], source = 0, destination = 1, target = 5

输出：[[4,1,1],[2,0,1],[0,3,3],[4,3,1]]

解释：上图展示了一个满足题意的修改方案，从 0 到 1 的最短距离为 5 。

```

示例 2：

```txt

输入：n = 3, edges = [[0,1,-1],[0,2,5]], source = 0, destination = 2, target = 6

输出：[]

解释：上图是一开始的图。没有办法通过修改边权为 -1 的边，使得 0 到 2 的最短距离等于 6 ，所以返回一个空数组。

```

示例 3：

```txt

输入：n = 4, edges = [[1,0,4],[1,2,3],[2,3,5],[0,3,-1]], source = 0, destination = 2, target = 6

输出：[[1,0,4],[1,2,3],[2,3,5],[0,3,1]]

解释：上图展示了一个满足题意的修改方案，从 0 到 2 的最短距离为 6 。

```

提示：

• 1 <= n <= 100

• 1 <= edges.length <= n * (n - 1) / 2

• edges[i].length == 3

• 0 <= ai, bi < n

• wi = -1 或者 1 <= wi <= 10^7

• ai != bi

• 0 <= source, destination < n

• source != destination

• 1 <= target <= 10^9

• 输入的图是连通图，且没有自环和重边。

2290. 到达角落需要移除障碍物的最小数目

给你一个下标从 0 开始的二维整数数组 grid ，数组大小为 m x n 。每个单元格都是两个值之一：

• 0 表示一个 空 单元格，

• 1 表示一个可以移除的 障碍物 。

你可以向上、下、左、右移动，从一个空单元格移动到另一个空单元格。

现在你需要从左上角 (0, 0) 移动到右下角 (m - 1, n - 1) ，返回需要移除的障碍物的 最小 数目。

示例 1：

```txt

输入：grid = [[0,1,1],[1,1,0],[1,1,0]]

输出：2

解释：可以移除位于 (0, 1) 和 (0, 2) 的障碍物来创建从 (0, 0) 到 (2, 2) 的路径。

可以证明我们至少需要移除两个障碍物，所以返回 2 。

注意，可能存在其他方式来移除 2 个障碍物，创建出可行的路径。

```

示例 2：

```txt

输入：grid = [[0,1,0,0,0],[0,1,0,1,0],[0,0,0,1,0]]

输出：0

解释：不移除任何障碍物就能从 (0, 0) 到 (2, 4) ，所以返回 0 。

```

提示：

• m == grid.length

• n == grid[i].length

• 1 <= m, n <= 10^5

• 2 <= m * n <= 10^5

• grid[i][j] 为 0 或 1

• grid[0][0] == grid[m - 1][n - 1] == 0

6366. 在网格图中访问一个格子的最少时间

给你一个 m x n 的矩阵 grid ，每个元素都为 非负 整数，其中 grid[row][col] 表示可以访问格子 (row, col) 的 最早 时间。也就是说当你访问格子 (row, col) 时，最少已经经过的时间为 grid[row][col] 。

你从 最左上角 出发，出发时刻为 0 ，你必须一直移动到上下左右相邻四个格子中的 任意 一个格子（即不能停留在格子上）。每次移动都需要花费 1 单位时间。

请你返回 最早 到达右下角格子的时间，如果你无法到达右下角的格子，请你返回 -1 。

示例 1：

```txt

输入：grid = [[0,1,3,2],[5,1,2,5],[4,3,8,6]]

输出：7

解释：一条可行的路径为：

• 时刻 t = 0 ，我们在格子 (0,0) 。

• 时刻 t = 1 ，我们移动到格子 (0,1) ，可以移动的原因是 grid[0][1] <= 1 。

• 时刻 t = 2 ，我们移动到格子 (1,1) ，可以移动的原因是 grid[1][1] <= 2 。

• 时刻 t = 3 ，我们移动到格子 (1,2) ，可以移动的原因是 grid[1][2] <= 3 。

• 时刻 t = 4 ，我们移动到格子 (1,1) ，可以移动的原因是 grid[1][1] <= 4 。

• 时刻 t = 5 ，我们移动到格子 (1,2) ，可以移动的原因是 grid[1][2] <= 5 。

• 时刻 t = 6 ，我们移动到格子 (1,3) ，可以移动的原因是 grid[1][3] <= 6 。

• 时刻 t = 7 ，我们移动到格子 (2,3) ，可以移动的原因是 grid[2][3] <= 7 。

最终到达时刻为 7 。这是最早可以到达的时间。

```

示例 2：

```txt

输入：grid = [[0,2,4],[3,2,1],[1,0,4]]

输出：-1

解释：没法从左上角按题目规定走到右下角。

```

提示：

• m == grid.length

• n == grid[i].length

• 2 <= m, n <= 1000

• 4 <= m * n <= 10^5

• 0 <= grid[i][j] <= 10^5

• grid[0][0] == 0

6336. 设计可以求最短路径的图类

给你一个有 n 个节点的 有向带权 图，节点编号为 0 到 n - 1 。图中的初始边用数组 edges 表示，其中 edges[i] = [fromi, toi, edgeCosti] 表示从 fromi 到 toi 有一条代价为 edgeCosti 的边。

请你实现一个 Graph 类：

• Graph(int n, int[][] edges) 初始化图有 n 个节点，并输入初始边。

• addEdge(int[] edge) 向边集中添加一条边，其中 edge = [from, to, edgeCost] 。数据保证添加这条边之前对应的两个节点之间没有有向边。

• int shortestPath(int node1, int node2) 返回从节点 node1 到 node2 的路径 最小 代价。如果路径不存在，返回 -1 。一条路径的代价是路径中所有边代价之和。

示例 1：

```txt

输入：

["Graph", "shortestPath", "shortestPath", "addEdge", "shortestPath"]

[[4, [[0, 2, 5], [0, 1, 2], [1, 2, 1], [3, 0, 3]]], [3, 2], [0, 3], [[1, 3, 4]], [0, 3]]

输出：

[null, 6, -1, null, 6]

解释：

Graph g = new Graph(4, [[0, 2, 5], [0, 1, 2], [1, 2, 1], [3, 0, 3]]);

g.shortestPath(3, 2); // 返回 6 。从 3 到 2 的最短路径如第一幅图所示：3 -> 0 -> 1 -> 2 ，总代价为 3 + 2 + 1 = 6 。

g.shortestPath(0, 3); // 返回 -1 。没有从 0 到 3 的路径。

g.addEdge([1, 3, 4]); // 添加一条节点 1 到节点 3 的边，得到第二幅图。

g.shortestPath(0, 3); // 返回 6 。从 0 到 3 的最短路径为 0 -> 1 -> 3 ，总代价为 2 + 4 = 6 。

```

提示：

• 1 <= n <= 100

• 0 <= edges.length <= n * (n - 1)

• edges[i].length == edge.length == 3

• 0 <= fromi, toi, from, to, node1, node2 <= n - 1

• 1 <= edgeCosti, edgeCost <= 10^6

• 图中任何时候都不会有重边和自环。

• 调用 addEdge 至多 100 次。

• 调用 shortestPath 至多 100 次。

862. 和至少为 K 的最短子数组

给你一个整数数组 nums 和一个整数 k ，找出 nums 中和至少为 k 的 最短非空子数组 ，并返回该子数组的长度。如果不存在这样的 子数组 ，返回 -1 。

子数组 是数组中 连续 的一部分。

示例 1：

```txt

输入：nums = [1], k = 1

输出：1

```

示例 2：

```txt

输入：nums = [1,2], k = 4

输出：-1

```

示例 3：

```txt

输入：nums = [2,-1,2], k = 3

输出：3

```

提示：

• 1 <= nums.length <= 10^5

• -10^5 <= nums[i] <= 10^5

• 1 <= k <= 10^9