fork()==0世界线变动

2983. 回文串重新排列查询

给你一个长度为 偶数 n ，下标从 0 开始的字符串 s 。

同时给你一个下标从 0 开始的二维整数数组 queries ，其中 queries[i] = [ai, bi, ci, di] 。

对于每个查询 i ，你需要执行以下操作：

• 将下标在范围 0 <= ai <= bi < n / 2 内的 子字符串 s[ai:bi] 中的字符重新排列。

• 将下标在范围 n / 2 <= ci <= di < n 内的 子字符串 s[ci:di] 中的字符重新排列。

对于每个查询，你的任务是判断执行操作后能否让 s 变成一个 回文串 。

每个查询与其他查询都是 独立的 。

请你返回一个下标从 0 开始的数组 answer ，如果第 i 个查询执行操作后，可以将 s 变为一个回文串，那么 answer[i] = true，否则为 false 。

• 子字符串 指的是一个字符串中一段连续的字符序列。

• s[x:y] 表示 s 中从下标 x 到 y 且两个端点 都包含 的子字符串。

示例 1：

```txt

输入：s = "abcabc", queries = [[1,1,3,5],[0,2,5,5]]

输出：[true,true]

解释：这个例子中，有 2 个查询：

第一个查询：

• a0 = 1, b0 = 1, c0 = 3, d0 = 5

• 你可以重新排列 s[1:1] => abcabc 和 s[3:5] => abcabc 。

• 为了让 s 变为回文串，s[3:5] 可以重新排列得到 => abccba 。

• 现在 s 是一个回文串。所以 answer[0] = true 。

第二个查询：

• a1 = 0, b1 = 2, c1 = 5, d1 = 5.

• 你可以重新排列 s[0:2] => abcabc 和 s[5:5] => abcabc 。

• 为了让 s 变为回文串，s[0:2] 可以重新排列得到 => cbaabc 。

• 现在 s 是一个回文串，所以 answer[1] = true 。

```

示例 2：

```txt

输入：s = "abbcdecbba", queries = [[0,2,7,9]]

输出：[false]

解释：这个示例中，只有一个查询。

a0 = 0, b0 = 2, c0 = 7, d0 = 9.

你可以重新排列 s[0:2] => abbcdecbba 和 s[7:9] => abbcdecbba 。

无法通过重新排列这些子字符串使 s 变为一个回文串，因为 s[3:6] 不是一个回文串。

所以 answer[0] = false 。

```

示例 3：

```txt

输入：s = "acbcab", queries = [[1,2,4,5]]

输出：[true]

解释：这个示例中，只有一个查询。

a0 = 1, b0 = 2, c0 = 4, d0 = 5.

你可以重新排列 s[1:2] => acbcab 和 s[4:5] => acbcab 。

为了让 s 变为回文串，s[1:2] 可以重新排列得到 => abccab 。

然后 s[4:5] 重新排列得到 abccba 。

现在 s 是一个回文串，所以 answer[0] = true 。

```

提示：

• 2 <= n == s.length <= 10^5

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

• queries[i].length == 4

• ai == queries[i][0], bi == queries[i][1]

• ci == queries[i][2], di == queries[i][3]

• 0 <= ai <= bi < n / 2

• n / 2 <= ci <= di < n

• n 是一个偶数。

• s 只包含小写英文字母。

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

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

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

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