代码如诗

6345. 重排水果

你有两个果篮，每个果篮中有 n 个水果。给你两个下标从 0 开始的整数数组 basket1 和 basket2 ，用以表示两个果篮中每个水果的成本。

你希望两个果篮相等。为此，可以根据需要多次执行下述操作：

• 选中两个下标 i 和 j ，并交换 basket1 中的第 i 个水果和 basket2 中的第 j 个水果。

• 交换的成本是 min(basket1i,basket2j) 。

根据果篮中水果的成本进行排序，如果排序后结果完全相同，则认为两个果篮相等。

返回使两个果篮相等的最小交换成本，如果无法使两个果篮相等，则返回 -1 。

示例 1：

```txt

输入：basket1 = [4,2,2,2], basket2 = [1,4,1,2]

输出：1

解释：交换 basket1 中下标为 1 的水果和 basket2 中下标为 0 的水果，交换的成本为 1 。此时，basket1 = [4,1,2,2] 且 basket2 = [2,4,1,2] 。重排两个数组，发现二者相等。

```

示例 2：

```txt

输入：basket1 = [2,3,4,1], basket2 = [3,2,5,1]

输出：-1

解释：可以证明无法使两个果篮相等。

```

提示：

• basket1.length == bakste2.length

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

• 1 <= basket1i,basket2i <= 10^9

2790. 长度递增组的最大数目

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

你的任务是使用从 0 到 n - 1 的数字创建若干组，并确保每个数字 i 在 所有组 中使用的次数总共不超过 usageLimits[i] 次。此外，还必须满足以下条件：

• 每个组必须由 不同 的数字组成，也就是说，单个组内不能存在重复的数字。

• 每个组（除了第一个）的长度必须 严格大于 前一个组。

在满足所有条件的情况下，以整数形式返回可以创建的最大组数。

示例 1：

```txt

输入：usageLimits = [1,2,5]

输出：3

解释：在这个示例中，我们可以使用 0 至多一次，使用 1 至多 2 次，使用 2 至多 5 次。

一种既能满足所有条件，又能创建最多组的方式是：

组 1 包含数字 [2] 。

组 2 包含数字 [1,2] 。

组 3 包含数字 [0,1,2] 。

可以证明能够创建的最大组数是 3 。

所以，输出是 3 。

```

示例 2：

```txt

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

输出：2

解释：在这个示例中，我们可以使用 0 至多 2 次，使用 1 至多 1 次，使用 2 至多 2 次。

一种既能满足所有条件，又能创建最多组的方式是：

组 1 包含数字 [0] 。

组 2 包含数字 [1,2] 。

可以证明能够创建的最大组数是 2 。

所以，输出是 2 。

```

示例 3：

```txt

输入：usageLimits = [1,1]

输出：1

解释：在这个示例中，我们可以使用 0 和 1 至多 1 次。

一种既能满足所有条件，又能创建最多组的方式是：

组 1 包含数字 [0] 。

可以证明能够创建的最大组数是 1 。

所以，输出是 1 。

```

提示：

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

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

810. 黑板异或游戏

黑板上写着一个非负整数数组 nums[i] 。

Alice 和 Bob 轮流从黑板上擦掉一个数字，Alice 先手。如果擦除一个数字后，剩余的所有数字按位异或运算得出的结果等于 0 的话，当前玩家游戏失败。 另外，如果只剩一个数字，按位异或运算得到它本身；如果无数字剩余，按位异或运算结果为 0。

并且，轮到某个玩家时，如果当前黑板上所有数字按位异或运算结果等于 0 ，这个玩家获胜。

假设两个玩家每步都使用最优解，当且仅当 Alice 获胜时返回 true。

示例 1：

```txt

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

输出: false

解释:

Alice 有两个选择: 擦掉数字 1 或 2。

如果擦掉 1, 数组变成 [1, 2]。剩余数字按位异或得到 1 XOR 2 = 3。那么 Bob 可以擦掉任意数字，因为 Alice 会成为擦掉最后一个数字的人，她总是会输。

如果 Alice 擦掉 2，那么数组变成[1, 1]。剩余数字按位异或得到 1 XOR 1 = 0。Alice 仍然会输掉游戏。

```

示例 2:

```txt

输入: nums = [0,1]

输出: true

```

示例 3:

```txt

输入: nums = [1,2,3]

输出: true

```

提示：

• 1 <= nums.length <= 1000

• 0 <= nums[i] < 2^16

1092. 最短公共超序列

给你两个字符串 str1 和 str2，返回同时以 str1 和 str2 作为 子序列 的最短字符串。如果答案不止一个，则可以返回满足条件的 任意一个 答案。

如果从字符串 t 中删除一些字符（也可能不删除），可以得到字符串 s ，那么 s 就是 t 的一个子序列。

示例 1：

```txt

输入：str1 = "abac", str2 = "cab"

输出："cabac"

解释：

str1 = "abac" 是 "cabac" 的一个子串，因为我们可以删去 "cabac" 的第一个 "c"得到 "abac"。

str2 = "cab" 是 "cabac" 的一个子串，因为我们可以删去 "cabac" 末尾的 "ac" 得到 "cab"。

最终我们给出的答案是满足上述属性的最短字符串。

```

示例 2：

```txt

输入：str1 = "aaaaaaaa", str2 = "aaaaaaaa"

输出："aaaaaaaa"

```

提示：

• 1 <= str1.length, str2.length <= 1000

• str1 和 str2 都由小写英文字母组成。

1039. 多边形三角剖分的最低得分

你有一个凸的 n 边形，其每个顶点都有一个整数值。给定一个整数数组 values ，其中 values[i] 是第 i 个顶点的值（即 顺时针顺序 ）。

假设将多边形 剖分 为 n - 2 个三角形。对于每个三角形，该三角形的值是顶点标记的乘积，三角剖分的分数是进行三角剖分后所有 n - 2 个三角形的值之和。

返回 多边形进行三角剖分后可以得到的最低分 。

示例 1：

```txt

输入：values = [1,2,3]

输出：6

解释：多边形已经三角化，唯一三角形的分数为 6。

```

示例 2：

```txt

输入：values = [3,7,4,5]

输出：144

解释：有两种三角剖分，可能得分分别为：375 + 457 = 245，或 345 + 347 = 144。最低分数为 144。

```

示例 3：

```txt

输入：values = [1,3,1,4,1,5]

输出：13

解释：最低分数三角剖分的得分情况为 113 + 114 + 115 + 111 = 13。

```

提示：

• n == values.length

• 3 <= n <= 50

• 1 <= values[i] <= 100

100163. 统计强大整数的数目

给你三个整数 start ，finish 和 limit 。同时给你一个下标从 0 开始的字符串 s ，表示一个 正 整数。

如果一个 正 整数 x 末尾部分是 s （换句话说，s 是 x 的 后缀），且 x 中的每个数位至多是 limit ，那么我们称 x 是 强大的 。

请你返回区间 [start..finish] 内强大整数的 总数目 。

如果一个字符串 x 是 y 中某个下标开始（包括 0 ），到下标为 y.length - 1 结束的子字符串，那么我们称 x 是 y 的一个后缀。比方说，25 是 5125 的一个后缀，但不是 512 的后缀。

示例 1：

```txt

输入：start = 1, finish = 6000, limit = 4, s = "124"

输出：5

解释：区间 [1..6000] 内的强大数字为 124 ，1124 ，2124 ，3124 和 4124 。这些整数的各个数位都 <= 4 且 "124" 是它们的后缀。注意 5124 不是强大整数，因为第一个数位 5 大于 4 。

这个区间内总共只有这 5 个强大整数。

```

示例 2：

```txt

输入：start = 15, finish = 215, limit = 6, s = "10"

输出：2

解释：区间 [15..215] 内的强大整数为 110 和 210 。这些整数的各个数位都 <= 6 且 "10" 是它们的后缀。

这个区间总共只有这 2 个强大整数。

```

示例 3：

```txt

输入：start = 1000, finish = 2000, limit = 4, s = "3000"

输出：0

解释：区间 [1000..2000] 内的整数都小于 3000 ，所以 "3000" 不可能是这个区间内任何整数的后缀。

```

提示：

• 1 <= start <= finish <= 10^15

• 1 <= limit <= 9

• 1 <= s.length <= floor(log10(finish)) + 1

• s 数位中每个数字都小于等于 limit 。

• s 不包含任何前导 0 。

2858. 可以到达每一个节点的最少边反转次数

给你一个 n 个点的 简单有向图 （没有重复边的有向图），节点编号为 0 到 n - 1 。如果这些边是双向边，那么这个图形成一棵 树 。

给你一个整数 n 和一个 二维 整数数组 edges ，其中 edges[i] = [ui, vi] 表示从节点 ui 到节点 vi 有一条 有向边 。

边反转 指的是将一条边的方向反转，也就是说一条从节点 ui 到节点 vi 的边会变为一条从节点 vi 到节点 ui 的边。

对于范围 [0, n - 1] 中的每一个节点 i ，你的任务是分别 独立 计算 最少 需要多少次 边反转 ，从节点 i 出发经过 一系列有向边 ，可以到达所有的节点。

请你返回一个长度为 n 的整数数组 answer ，其中 answer[i]表示从节点 i 出发，可以到达所有节点的 最少边反转 次数。

示例 1：

```txt

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

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

解释：上图表示了与输入对应的简单有向图。

对于节点 0 ：反转 [2,0] ，从节点 0 出发可以到达所有节点。

所以 answer[0] = 1 。

对于节点 1 ：反转 [2,1] ，从节点 1 出发可以到达所有节点。

所以 answer[1] = 1 。

对于节点 2 ：不需要反转就可以从节点 2 出发到达所有节点。

所以 answer[2] = 0 。

对于节点 3 ：反转 [1,3] 和 [2,1] ，从节点 3 出发可以到达所有节点。

所以 answer[3] = 2 。

```

示例 2：

```txt

输入：n = 3, edges = [[1,2],[2,0]]

输出：[2,0,1]

解释：上图表示了与输入对应的简单有向图。

对于节点 0 ：反转 [2,0] 和 [1,2] ，从节点 0 出发可以到达所有节点。

所以 answer[0] = 2 。

对于节点 1 ：不需要反转就可以从节点 2 出发到达所有节点。

所以 answer[1] = 0 。

对于节点 2 ：反转 [1,2] ，从节点 2 出发可以到达所有节点。

所以 answer[2] = 1 。

```

提示：

• 2 <= n <= 10^5

• edges.length == n - 1

• edges[i].length == 2

• 0 <= ui == edges[i][0] < n

• 0 <= vi == edges[i][1] < n

• ui != vi

• 输入保证如果边是双向边，可以得到一棵树。