代码如诗

1632. 矩阵转换后的秩

给你一个 m x n 的矩阵 matrix ，请你返回一个新的矩阵 answer ，其中 answer[row][col] 是 matrix[row][col] 的秩。

每个元素的 秩 是一个整数，表示这个元素相对于其他元素的大小关系，它按照如下规则计算：

• 秩是从 1 开始的一个整数。

• 如果两个元素 p 和 q 在 同一行 或者 同一列 ，那么：

  • 如果 p < q ，那么 rank(p) < rank(q)

  • 如果 p == q ，那么 rank(p) == rank(q)

  • 如果 p > q ，那么 rank(p) > rank(q)

• 秩 需要越 小 越好。

题目保证按照上面规则 answer 数组是唯一的。

示例 1：

```txt

输入：matrix = [[1,2],[3,4]]

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

解释：

matrix[0][0] 的秩为 1 ，因为它是所在行和列的最小整数。

matrix[0][1] 的秩为 2 ，因为 matrix[0][1] > matrix[0][0] 且 matrix[0][0] 的秩为 1 。

matrix[1][0] 的秩为 2 ，因为 matrix[1][0] > matrix[0][0] 且 matrix[0][0] 的秩为 1 。

matrix[1][1] 的秩为 3 ，因为 matrix[1][1] > matrix[0][1]， matrix[1][1] > matrix[1][0] 且 matrix[0][1] 和 matrix[1][0] 的秩都为 2 。

```

示例 2：

```txt

输入：matrix = [[7,7],[7,7]]

输出：[[1,1],[1,1]]

```

示例 3：

```txt

输入：matrix = [[20,-21,14],[-19,4,19],[22,-47,24],[-19,4,19]]

输出：[[4,2,3],[1,3,4],[5,1,6],[1,3,4]]

```

示例 4：

```txt

输入：matrix = [[7,3,6],[1,4,5],[9,8,2]]

输出：[[5,1,4],[1,2,3],[6,3,1]]

```

提示：

• m == matrix.length

• n == matrix[i].length

• 1 <= m, n <= 500

• -10^9 <= matrix[row][col] <= 10^9

2856. 删除数对后的最小数组长度

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

你可以执行以下操作任意次：

• 选择 两个 下标 i 和 j ，满足 i < j 且 nums[i] < nums[j] 。

• 将 nums 中下标在 i 和 j 处的元素删除。剩余元素按照原来的顺序组成新的数组，下标也重新从 0 开始编号。

请你返回一个整数，表示执行以上操作任意次后（可以执行 0 次），nums 数组的 最小 数组长度。

示例 1：

```txt

输入：nums = [1,3,4,9]

输出：0

解释：一开始，nums = [1, 3, 4, 9] 。

第一次操作，我们选择下标 0 和 1 ，满足 nums[0] < nums[1] <=> 1 < 3 。

删除下标 0 和 1 处的元素，nums 变成 [4, 9] 。

下一次操作，我们选择下标 0 和 1 ，满足 nums[0] < nums[1] <=> 4 < 9 。

删除下标 0 和 1 处的元素，nums 变成空数组 [] 。

所以，可以得到的最小数组长度为 0 。

```

示例 2：

```txt

输入：nums = [2,3,6,9]

输出：0

解释：一开始，nums = [2, 3, 6, 9] 。

第一次操作，我们选择下标 0 和 2 ，满足 nums[0] < nums[2] <=> 2 < 6 。

删除下标 0 和 2 处的元素，nums 变成 [3, 9] 。

下一次操作，我们选择下标 0 和 1 ，满足 nums[0] < nums[1] <=> 3 < 9 。

删除下标 0 和 1 处的元素，nums 变成空数组 [] 。

所以，可以得到的最小数组长度为 0 。

```

示例 3：

```txt

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

输出：1

解释：一开始，nums = [1, 1, 2] 。

第一次操作，我们选择下标 0 和 2 ，满足 nums[0] < nums[2] <=> 1 < 2 。

删除下标 0 和 2 处的元素，nums 变成 [1] 。

无法对数组再执行操作。

所以，可以得到的最小数组长度为 1 。

```

提示：

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

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

• nums 是 非递减 数组。

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

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