fork()==0世界线变动

2531. 使字符串总不同字符的数目相等

给你两个下标从 0 开始的字符串 word1 和 word2 。

一次 移动 由以下两个步骤组成：

• 选中两个下标 i 和 j ，分别满足 0 <= i < word1.length 和 0 <= j < word2.length ，

• 交换 word1[i] 和 word2[j] 。

如果可以通过 恰好一次 移动，使 word1 和 word2 中不同字符的数目相等，则返回 true ；否则，返回 false 。

示例 1：

```txt

输入：word1 = "ac", word2 = "b"

输出：false

解释：交换任何一组下标都会导致第一个字符串中有 2 个不同的字符，而在第二个字符串中只有 1 个不同字符。

```

示例 2：

```txt

输入：word1 = "abcc", word2 = "aab"

输出：true

解释：交换第一个字符串的下标 2 和第二个字符串的下标 0 。之后得到 word1 = "abac" 和 word2 = "cab" ，各有 3 个不同字符。

```

示例 3：

```txt

输入：word1 = "abcde", word2 = "fghij"

输出：true

解释：无论交换哪一组下标，两个字符串中都会有 5 个不同字符。

```

提示：

• 1 <= word1.length, word2.length <= 10^5

• word1 和 word2 仅由小写英文字母组成。

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 。

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 用以表示一组基于题目描述中语法构造的字符串