fork()==0世界线变动

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

1851. 包含每个查询的最小区间

给你一个二维整数数组 intervals ，其中 intervals[i] = [lefti, righti] 表示第 i 个区间开始于 lefti 、结束于 righti（包含两侧取值，闭区间）。区间的 长度 定义为区间中包含的整数数目，更正式地表达是 righti - lefti + 1 。

再给你一个整数数组 queries 。第 j 个查询的答案是满足 lefti <= queries[j] <= righti 的 长度最小区间 i 的长度 。如果不存在这样的区间，那么答案是 -1 。

以数组形式返回对应查询的所有答案。

示例 1：

```txt

输入：intervals = [[1,4],[2,4],[3,6],[4,4]], queries = [2,3,4,5]

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

解释：查询处理如下：

• Query = 2 ：区间 [2,4] 是包含 2 的最小区间，答案为 4 - 2 + 1 = 3 。

• Query = 3 ：区间 [2,4] 是包含 3 的最小区间，答案为 4 - 2 + 1 = 3 。

• Query = 4 ：区间 [4,4] 是包含 4 的最小区间，答案为 4 - 4 + 1 = 1 。

• Query = 5 ：区间 [3,6] 是包含 5 的最小区间，答案为 6 - 3 + 1 = 4 。

```

示例 2：

```txt

输入：intervals = [[2,3],[2,5],[1,8],[20,25]], queries = [2,19,5,22]

输出：[2,-1,4,6]

解释：查询处理如下：

• Query = 2 ：区间 [2,3] 是包含 2 的最小区间，答案为 3 - 2 + 1 = 2 。

• Query = 19：不存在包含 19 的区间，答案为 -1 。

• Query = 5 ：区间 [2,5] 是包含 5 的最小区间，答案为 5 - 2 + 1 = 4 。

• Query = 22：区间 [20,25] 是包含 22 的最小区间，答案为 25 - 20 + 1 = 6 。

```

提示：

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

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

• queries[i].length == 2

• 1 <= lefti <= righti <= 10^7

• 1 <= queries[j] <= 10^7

2916. 子数组不同元素数目的平方和 II

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

定义 nums 一个子数组的 不同计数 值如下：

• 令 nums[i..j] 表示 nums 中所有下标在 i 到 j 范围内的元素构成的子数组（满足 0 <= i <= j < nums.length ），那么我们称子数组 nums[i..j] 中不同值的数目为 nums[i..j] 的不同计数。

请你返回 nums 中所有子数组的 不同计数 的 平方 和。

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

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

示例 1：

```txt

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

输出：15

解释：六个子数组分别为：

[1]: 1 个互不相同的元素。

[2]: 1 个互不相同的元素。

[1]: 1 个互不相同的元素。

[1,2]: 2 个互不相同的元素。

[2,1]: 2 个互不相同的元素。

[1,2,1]: 2 个互不相同的元素。

所有不同计数的平方和为 12 + 12 + 12 + 22 + 22 + 22 = 15 。

```

示例 2：

```txt

输入：nums = [2,2]

输出：3

解释：三个子数组分别为：

[2]: 1 个互不相同的元素。

[2]: 1 个互不相同的元素。

[2,2]: 1 个互不相同的元素。

所有不同计数的平方和为 12 + 12 + 12 = 3 。

```

提示：

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

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

2940. 找到 Alice 和 Bob 可以相遇的建筑

给你一个下标从 0 开始的正整数数组 heights ，其中 heights[i] 表示第 i 栋建筑的高度。

如果一个人在建筑 i ，且存在 i < j 的建筑 j 满足 heights[i] < heights[j] ，那么这个人可以移动到建筑 j 。

给你另外一个数组 queries ，其中 queries[i] = [ai, bi] 。第 i 个查询中，Alice 在建筑 ai ，Bob 在建筑 bi 。

请你能返回一个数组 ans ，其中 ans[i] 是第 i 个查询中，Alice 和 Bob 可以相遇的 最左边的建筑 。如果对于查询 i ，Alice 和 Bob 不能相遇，令 ans[i] 为 -1 。

示例 1：

```txt

输入：heights = [6,4,8,5,2,7], queries = [[0,1],[0,3],[2,4],[3,4],[2,2]]

输出：[2,5,-1,5,2]

解释：第一个查询中，Alice 和 Bob 可以移动到建筑 2 ，因为 heights[0] < heights[2] 且 heights[1] < heights[2] 。

第二个查询中，Alice 和 Bob 可以移动到建筑 5 ，因为 heights[0] < heights[5] 且 heights[3] < heights[5] 。

第三个查询中，Alice 无法与 Bob 相遇，因为 Alice 不能移动到任何其他建筑。

第四个查询中，Alice 和 Bob 可以移动到建筑 5 ，因为 heights[3] < heights[5] 且 heights[4] < heights[5] 。

第五个查询中，Alice 和 Bob 已经在同一栋建筑中。

对于 ans[i] != -1 ，ans[i] 是 Alice 和 Bob 可以相遇的建筑中最左边建筑的下标。

对于 ans[i] == -1 ，不存在 Alice 和 Bob 可以相遇的建筑。

```

示例 2：

```txt

输入：heights = [5,3,8,2,6,1,4,6], queries = [[0,7],[3,5],[5,2],[3,0],[1,6]]

输出：[7,6,-1,4,6]

解释：第一个查询中，Alice 可以直接移动到 Bob 的建筑，因为 heights[0] < heights[7] 。

第二个查询中，Alice 和 Bob 可以移动到建筑 6 ，因为 heights[3] < heights[6] 且 heights[5] < heights[6] 。

第三个查询中，Alice 无法与 Bob 相遇，因为 Bob 不能移动到任何其他建筑。

第四个查询中，Alice 和 Bob 可以移动到建筑 4 ，因为 heights[3] < heights[4] 且 heights[0] < heights[4] 。

第五个查询中，Alice 可以直接移动到 Bob 的建筑，因为 heights[1] < heights[6] 。

对于 ans[i] != -1 ，ans[i] 是 Alice 和 Bob 可以相遇的建筑中最左边建筑的下标。

对于 ans[i] == -1 ，不存在 Alice 和 Bob 可以相遇的建筑。

```

提示：

• 1 <= heights.length <= 5 * 10^4

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

• 1 <= queries.length <= 5 * 10^4

• queries[i] = [ai, bi]

• 0 <= ai, bi <= heights.length - 1

2736. 最大和查询

给你两个长度为 n 、下标从 0 开始的整数数组 nums1 和 nums2 ，另给你一个下标从 1 开始的二维数组 queries ，其中 queries[i] = [xi, yi] 。

对于第 i 个查询，在所有满足 nums1[j] >= xi 且 nums2[j] >= yi 的下标 j (0 <= j < n) 中，找出 nums1[j] + nums2[j] 的 最大值 ，如果不存在满足条件的 j 则返回 -1 。

返回数组 answer ，其中 answer[i] 是第 i 个查询的答案。

示例 1：

```txt

输入：nums1 = [4,3,1,2], nums2 = [2,4,9,5], queries = [[4,1],[1,3],[2,5]]

输出：[6,10,7]

解释：

对于第 1 个查询：xi = 4 且 yi = 1 ，可以选择下标 j = 0 ，此时 nums1[j] >= 4 且 nums2[j] >= 1 。nums1[j] + nums2[j] 等于 6 ，可以证明 6 是可以获得的最大值。

对于第 2 个查询：xi = 1 且 yi = 3 ，可以选择下标 j = 2 ，此时 nums1[j] >= 1 且 nums2[j] >= 3 。nums1[j] + nums2[j] 等于 10 ，可以证明 10 是可以获得的最大值。

对于第 3 个查询：xi = 2 且 yi = 5 ，可以选择下标 j = 3 ，此时 nums1[j] >= 2 且 nums2[j] >= 5 。nums1[j] + nums2[j] 等于 7 ，可以证明 7 是可以获得的最大值。

因此，我们返回 [6,10,7] 。

```

示例 2：

```txt

输入：nums1 = [3,2,5], nums2 = [2,3,4], queries = [[4,4],[3,2],[1,1]]

输出：[9,9,9]

解释：对于这个示例，我们可以选择下标 j = 2 ，该下标可以满足每个查询的限制。

```

示例 3：

```txt

输入：nums1 = [2,1], nums2 = [2,3], queries = [[3,3]]

输出：[-1]

解释：示例中的查询 xi = 3 且 yi = 3 。对于每个下标 j ，都只满足 nums1[j] < xi 或者 nums2[j] < yi 。因此，不存在答案。

```

提示：

• nums1.length == nums2.length 

• n == nums1.length 

• 1 <= n <= 10^5

• 1 <= nums1[i], nums2[i] <= 10^9 

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

• queries[i].length == 2

• xi == queries[i][1]

• yi == queries[i][2]

• 1 <= xi, yi <= 10^9