fork()==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

2945. 找到最大非递减数组的长度

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

你可以执行任意次操作。每次操作中，你需要选择一个 子数组 ，并将这个子数组用它所包含元素的 和 替换。比方说，给定数组是 [1,3,5,6] ，你可以选择子数组 [3,5] ，用子数组的和 8 替换掉子数组，然后数组会变为 [1,8,6] 。

请你返回执行任意次操作以后，可以得到的 最长非递减 数组的长度。

子数组 指的是一个数组中一段连续 非空 的元素序列。

示例 1：

```txt

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

输出：1

解释：这个长度为 3 的数组不是非递减的。

我们有 2 种方案使数组长度为 2 。

第一种，选择子数组 [2,2] ，对数组执行操作后得到 [5,4] 。

第二种，选择子数组 [5,2] ，对数组执行操作后得到 [7,2] 。

这两种方案中，数组最后都不是 非递减 的，所以不是可行的答案。

如果我们选择子数组 [5,2,2] ，并将它替换为 [9] ，数组变成非递减的。

所以答案为 1 。

```

示例 2：

```txt

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

输出：4

解释：数组已经是非递减的。所以答案为 4 。

```

示例 3：

```txt

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

输出：3

解释：将 [3,2] 替换为 [5] ，得到数组 [4,5,6] ，它是非递减的。

最大可能的答案为 3 。

```

提示：

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

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

2818. 操作使得分最大

给你一个长度为 n 的正整数数组 nums 和一个整数 k 。

一开始，你的分数为 1 。你可以进行以下操作至多 k 次，目标是使你的分数最大：

• 选择一个之前没有选过的 非空 子数组 nums[l, ..., r] 。

• 从 nums[l, ..., r] 里面选择一个 质数分数 最高的元素 x 。如果多个元素质数分数相同且最高，选择下标最小的一个。

• 将你的分数乘以 x 。

nums[l, ..., r] 表示 nums 中起始下标为 l ，结束下标为 r 的子数组，两个端点都包含。

一个整数的 质数分数 等于 x 不同质因子的数目。比方说， 300 的质数分数为 3 ，因为 300 = 2 * 2 * 3 * 5 * 5 。

请你返回进行至多 k 次操作后，可以得到的 最大分数 。

由于答案可能很大，请你将结果对 10^9 + 7 取余后返回。

示例 1：

```txt

输入：nums = [8,3,9,3,8], k = 2

输出：81

解释：进行以下操作可以得到分数 81 ：

• 选择子数组 nums[2, ..., 2] 。nums[2] 是子数组中唯一的元素。所以我们将分数乘以 nums[2] ，分数变为 1 * 9 = 9 。

• 选择子数组 nums[2, ..., 3] 。nums[2] 和 nums[3] 质数分数都为 1 ，但是 nums[2] 下标更小。所以我们将分数乘以 nums[2] ，分数变为 9 * 9 = 81 。

81 是可以得到的最高得分。

```

示例 2：

```txt

输入：nums = [19,12,14,6,10,18], k = 3

输出：4788

解释：进行以下操作可以得到分数 4788 ：

• 选择子数组 nums[0, ..., 0] 。nums[0] 是子数组中唯一的元素。所以我们将分数乘以 nums[0] ，分数变为 1 * 19 = 19 。

• 选择子数组 nums[5, ..., 5] 。nums[5] 是子数组中唯一的元素。所以我们将分数乘以 nums[5] ，分数变为 19 * 18 = 342 。

• 选择子数组 nums[2, ..., 3] 。nums[2] 和 nums[3] 质数分数都为 2，但是 nums[2] 下标更小。所以我们将分数乘以 nums[2] ，分数变为 342 * 14 = 4788 。

4788 是可以得到的最高的分。

```

提示：

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

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

• 1 <= k <= min(n * (n + 1) / 2, 10^9)

1096. 花括号展开 II

如果你熟悉 Shell 编程，那么一定了解过花括号展开，它可以用来生成任意字符串。

花括号展开的表达式可以看作一个由 花括号、逗号 和 小写英文字母 组成的字符串，定义下面几条语法规则：

• 如果只给出单一的元素 x，那么表达式表示的字符串就只有 "x"。R(x) = {x}

  • 例如，表达式 "a" 表示字符串 "a"。

  • 而表达式 "w" 就表示字符串 "w"。

• 当两个或多个表达式并列，以逗号分隔，我们取这些表达式中元素的并集。R({e_1,e_2,...}) = R(e_1) ∪ R(e_2) ∪ ...

  • 例如，表达式 "{a,b,c}" 表示字符串 "a","b","c"。

  • 而表达式 "{{a,b},{b,c}}" 也可以表示字符串 "a","b","c"。

• 要是两个或多个表达式相接，中间没有隔开时，我们从这些表达式中各取一个元素依次连接形成字符串。R(e_1 + e_2) = {a + b for (a, b) in R(e_1) × R(e_2)}

  • 例如，表达式 "{a,b}{c,d}" 表示字符串 "ac","ad","bc","bd"。

• 表达式之间允许嵌套，单一元素与表达式的连接也是允许的。

  • 例如，表达式 "a{b,c,d}" 表示字符串 "ab","ac","ad"​​​​​​。

  • 例如，表达式 "a{b,c}{d,e}f{g,h}" 可以表示字符串 "abdfg", "abdfh", "abefg", "abefh", "acdfg", "acdfh", "acefg", "acefh"。

给出表示基于给定语法规则的表达式 expression，返回它所表示的所有字符串组成的有序列表。

假如你希望以「集合」的概念了解此题，也可以通过点击 “显示英文描述” 获取详情。

示例 1：

```txt

输入：expression = "{a,b}{c,{d,e}}"

输出：["ac","ad","ae","bc","bd","be"]

```

示例 2：

```txt

输入：expression = "{{a,z},a{b,c},{ab,z}}"

输出：["a","ab","ac","z"]

解释：输出中 不应 出现重复的组合结果。

```

提示：

• 1 <= expression.length <= 60

• expression[i] 由 '{'，'}'，',' 或小写英文字母组成

• 给出的表达式 expression 用以表示一组基于题目描述中语法构造的字符串

1124. 表现良好的最长时间段

给你一份工作时间表 hours，上面记录着某一位员工每天的工作小时数。

我们认为当员工一天中的工作小时数大于 8 小时的时候，那么这一天就是「劳累的一天」。

所谓「表现良好的时间段」，意味在这段时间内，「劳累的天数」是严格 大于「不劳累的天数」。

请你返回「表现良好时间段」的最大长度。

示例 1：

```txt

输入：hours = [9,9,6,0,6,6,9]

输出：3

解释：最长的表现良好时间段是 [9,9,6]。

```

示例 2：

```txt

输入：hours = [6,6,6]

输出：0

```

提示：

• 1 <= hours.length <= 10^4

• 0 <= hours[i] <= 16

2532. 过桥的时间

共有 k 位工人计划将 n 个箱子从旧仓库移动到新仓库。给你两个整数 n 和 k，以及一个二维整数数组 time ，数组的大小为 k x 4 ，其中 time[i] = [leftToRighti, pickOldi, rightToLefti, putNewi] 。

一条河将两座仓库分隔，只能通过一座桥通行。旧仓库位于河的右岸，新仓库在河的左岸。开始时，所有 k 位工人都在桥的左侧等待。为了移动这些箱子，第 i 位工人（下标从 0 开始）可以：

• 从左岸（新仓库）跨过桥到右岸（旧仓库），用时 leftToRighti 分钟。

• 从旧仓库选择一个箱子，并返回到桥边，用时 pickOldi 分钟。不同工人可以同时搬起所选的箱子。

• 从右岸（旧仓库）跨过桥到左岸（新仓库），用时 rightToLefti 分钟。

• 将箱子放入新仓库，并返回到桥边，用时 putNewi 分钟。不同工人可以同时放下所选的箱子。

如果满足下面任一条件，则认为工人 i 的 效率低于 工人 j ：

• leftToRighti + rightToLefti > leftToRightj + rightToLeftj

• leftToRighti + rightToLefti == leftToRightj + rightToLeftj 且 i > j

工人通过桥时需要遵循以下规则：

• 如果工人 x 到达桥边时，工人 y 正在过桥，那么工人 x 需要在桥边等待。

• 如果没有正在过桥的工人，那么在桥右边等待的工人可以先过桥。如果同时有多个工人在右边等待，那么 效率最低 的工人会先过桥。

• 如果没有正在过桥的工人，且桥右边也没有在等待的工人，同时旧仓库还剩下至少一个箱子需要搬运，此时在桥左边的工人可以过桥。如果同时有多个工人在左边等待，那么 效率最低 的工人会先过桥。

所有 n 个盒子都需要放入新仓库，请你返回最后一个搬运箱子的工人 到达河左岸 的时间。

示例 1：

```txt

输入：n = 1, k = 3, time = [[1,1,2,1],[1,1,3,1],[1,1,4,1]]

输出：6

解释：

从 0 到 1 ：工人 2 从左岸过桥到达右岸。

从 1 到 2 ：工人 2 从旧仓库搬起一个箱子。

从 2 到 6 ：工人 2 从右岸过桥到达左岸。

从 6 到 7 ：工人 2 将箱子放入新仓库。

整个过程在 7 分钟后结束。因为问题关注的是最后一个工人到达左岸的时间，所以返回 6 。

```

示例 2：

```txt

输入：n = 3, k = 2, time = [[1,9,1,8],[10,10,10,10]]

输出：50

解释：

从 0 到 10 ：工人 1 从左岸过桥到达右岸。

从 10 到 20 ：工人 1 从旧仓库搬起一个箱子。

从 10 到 11 ：工人 0 从左岸过桥到达右岸。

从 11 到 20 ：工人 0 从旧仓库搬起一个箱子。

从 20 到 30 ：工人 1 从右岸过桥到达左岸。

从 30 到 40 ：工人 1 将箱子放入新仓库。

从 30 到 31 ：工人 0 从右岸过桥到达左岸。

从 31 到 39 ：工人 0 将箱子放入新仓库。

从 39 到 40 ：工人 0 从左岸过桥到达右岸。

从 40 到 49 ：工人 0 从旧仓库搬起一个箱子。

从 49 到 50 ：工人 0 从右岸过桥到达左岸。

从 50 到 58 ：工人 0 将箱子放入新仓库。

整个过程在 58 分钟后结束。因为问题关注的是最后一个工人到达左岸的时间，所以返回 50 。

```

提示：

• 1 <= n, k <= 10^4

• time.length == k

• time[i].length == 4

• 1 <= leftToRighti, pickOldi, rightToLefti, putNewi <= 1000