fork()==0世界线变动

2527. 查询数组 Xor 美丽值

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

三个下标 i ，j 和 k 的 有效值 定义为 ((nums[i] | nums[j]) & nums[k]) 。

一个数组的 xor 美丽值 是数组中所有满足 0 <= i, j, k < n  的三元组 (i, j, k) 的 有效值 的异或结果。

请你返回 nums 的 xor 美丽值。

注意：

• val1 | val2 是 val1 和 val2 的按位或。

• val1 & val2 是 val1 和 val2 的按位与。

示例 1：

```txt

输入：nums = [1,4]

输出：5

解释：

三元组和它们对应的有效值如下：

• (0,0,0) 有效值为 ((1 | 1) & 1) = 1

• (0,0,1) 有效值为 ((1 | 1) & 4) = 0

• (0,1,0) 有效值为 ((1 | 4) & 1) = 1

• (0,1,1) 有效值为 ((1 | 4) & 4) = 4

• (1,0,0) 有效值为 ((4 | 1) & 1) = 1

• (1,0,1) 有效值为 ((4 | 1) & 4) = 4

• (1,1,0) 有效值为 ((4 | 4) & 1) = 0

• (1,1,1) 有效值为 ((4 | 4) & 4) = 4

数组的 xor 美丽值为所有有效值的按位异或 1 ^ 0 ^ 1 ^ 4 ^ 1 ^ 4 ^ 0 ^ 4 = 5 。

```

示例 2：

```txt

输入：nums = [15,45,20,2,34,35,5,44,32,30]

输出：34

解释：数组的 xor 美丽值为 34 。

```

提示：

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

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

2033. 获取单值网格的最小操作数

给你一个大小为 m x n 的二维整数网格 grid 和一个整数 x 。每一次操作，你可以对 grid 中的任一元素 加 x 或 减 x 。

单值网格 是全部元素都相等的网格。

返回使网格化为单值网格所需的 最小 操作数。如果不能，返回 -1 。

示例 1：

```txt

输入：grid = [[2,4],[6,8]], x = 2

输出：4

解释：可以执行下述操作使所有元素都等于 4 ：

• 2 加 x 一次。

• 6 减 x 一次。

• 8 减 x 两次。

共计 4 次操作。

```

示例 2：

```txt

输入：grid = [[1,5],[2,3]], x = 1

输出：5

解释：可以使所有元素都等于 3 。

```

示例 3：

```txt

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

输出：-1

解释：无法使所有元素相等。

```

提示：

• m == grid.length

• n == grid[i].length

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

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

• 1 <= x, grid[i][j] <= 10^4

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