fork()==0世界线变动

6318. 完成所有任务的最少时间

你有一台电脑，它可以 同时 运行无数个任务。给你一个二维整数数组 tasks ，其中 tasks[i] = [starti, endi, durationi] 表示第 i 个任务需要在 闭区间 时间段 [starti, endi] 内运行 durationi 个整数时间点（但不需要连续）。

当电脑需要运行任务时，你可以打开电脑，如果空闲时，你可以将电脑关闭。

请你返回完成所有任务的情况下，电脑最少需要运行多少秒。

示例 1：

```txt

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

输出：2

解释：

• 第一个任务在闭区间 [2, 2] 运行。

• 第二个任务在闭区间 [5, 5] 运行。

• 第三个任务在闭区间 [2, 2] 和 [5, 5] 运行。

电脑总共运行 2 个整数时间点。

```

示例 2：

```txt

输入：tasks = [[1,3,2],[2,5,3],[5,6,2]]

输出：4

解释：

• 第一个任务在闭区间 [2, 3] 运行

• 第二个任务在闭区间 [2, 3] 和 [5, 5] 运行。

• 第三个任务在闭区间 [5, 6] 运行。

电脑总共运行 4 个整数时间点。

```

提示：

• 1 <= tasks.length <= 2000

• tasks[i].length == 3

• 1 <= starti, endi <= 2000

• 1 <= durationi <= endi - starti + 1

6360. 最小无法得到的或值

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

如果存在一些整数满足 0 <= index1 < index2 < ... < indexk < nums.length ，得到 nums[index1] | nums[index2] | ... | nums[indexk] = x ，那么我们说 x 是 可表达的 。换言之，如果一个整数能由 nums 的某个子序列的或运算得到，那么它就是可表达的。

请你返回 nums 不可表达的 最小非零整数 。

示例 1：

```txt

输入：nums = [2,1]

输出：4

解释：1 和 2 已经在数组中，因为 nums[0] | nums[1] = 2 | 1 = 3 ，所以 3 是可表达的。由于 4 是不可表达的，所以我们返回 4 。

```

示例 2：

```txt

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

输出：1

解释：1 是最小不可表达的数字。

```

提示：

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

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

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