代码如诗

3022. 给定操作次数内使剩余元素的或值最小

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

一次操作中，你可以选择 nums 中满足 0 <= i < nums.length - 1 的一个下标 i ，并将 nums[i] 和 nums[i + 1] 替换为数字 nums[i] & nums[i + 1] ，其中 & 表示按位 AND 操作。

请你返回 至多 k 次操作以内，使 nums 中所有剩余元素按位 OR 结果的 最小值 。

示例 1：

```txt

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

输出：3

解释：执行以下操作：

1. 将 nums[0] 和 nums[1] 替换为 (nums[0] & nums[1]) ，得到 nums 为 [1,3,2,7] 。

2. 将 nums[2] 和 nums[3] 替换为 (nums[2] & nums[3]) ，得到 nums 为 [1,3,2] 。

最终数组的按位或值为 3 。

3 是 k 次操作以内，可以得到的剩余元素的最小按位或值。

```

示例 2：

```txt

输入：nums = [7,3,15,14,2,8], k = 4

输出：2

解释：执行以下操作：

1. 将 nums[0] 和 nums[1] 替换为 (nums[0] & nums[1]) ，得到 nums 为 [3,15,14,2,8] 。

2. 将 nums[0] 和 nums[1] 替换为 (nums[0] & nums[1]) ，得到 nums 为 [3,14,2,8] 。

3. 将 nums[0] 和 nums[1] 替换为 (nums[0] & nums[1]) ，得到 nums 为 [2,2,8] 。

4. 将 nums[1] 和 nums[2] 替换为 (nums[1] & nums[2]) ，得到 nums 为 [2,0] 。

最终数组的按位或值为 2 。

2 是 k 次操作以内，可以得到的剩余元素的最小按位或值。

```

示例 3：

```txt

输入：nums = [10,7,10,3,9,14,9,4], k = 1

输出：15

解释：不执行任何操作，nums 的按位或值为 15 。

15 是 k 次操作以内，可以得到的剩余元素的最小按位或值。

```

提示：

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

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

• 0 <= k < nums.length

2836. 在传球游戏中最大化函数值

给你一个长度为 n 下标从 0 开始的整数数组 receiver 和一个整数 k 。

总共有 n 名玩家，玩家 编号 互不相同，且为 [0, n - 1] 中的整数。这些玩家玩一个传球游戏，receiver[i] 表示编号为 i 的玩家会传球给编号为 receiver[i] 的玩家。玩家可以传球给自己，也就是说 receiver[i] 可能等于 i 。

你需要从 n 名玩家中选择一名玩家作为游戏开始时唯一手中有球的玩家，球会被传 恰好 k 次。

如果选择编号为 x 的玩家作为开始玩家，定义函数 f(x) 表示从编号为 x 的玩家开始，k 次传球内所有接触过球玩家的编号之 和 ，如果有玩家多次触球，则 累加多次 。换句话说， f(x) = x + receiver[x] + receiver[receiver[x]] + ... + receiver^(k)[x] 。

你的任务时选择开始玩家 x ，目的是 最大化 f(x) 。

请你返回函数的 最大值 。

注意：receiver 可能含有重复元素。

示例 1：

传递次数

传球者编号

接球者编号

x + 所有接球者编号

2

1

2

1

3

2

1

0

3

3

0

2

5

4

2

1

6

```txt

输入：receiver = [2,0,1], k = 4

输出：6

解释：上表展示了从编号为 x = 2 开始的游戏过程。

从表中可知，f(2) 等于 6 。

6 是能得到最大的函数值。

所以输出为 6 。

```

示例 2：

传递次数

传球者编号

接球者编号

x + 所有接球者编号

4

1

4

3

7

2

3

2

9

3

2

1

10

```txt

输入：receiver = [1,1,1,2,3], k = 3

输出：10

解释：上表展示了从编号为 x = 4 开始的游戏过程。

从表中可知，f(4) 等于 10 。

10 是能得到最大的函数值。

所以输出为 10 。

```

提示：

• 1 <= receiver.length == n <= 10^5

• 0 <= receiver[i] <= n - 1

• 1 <= k <= 10^10

2846. 边权重均等查询

现有一棵由 n 个节点组成的无向树，节点按从 0 到 n - 1 编号。给你一个整数 n 和一个长度为 n - 1 的二维整数数组 edges ，其中 edges[i] = [ui, vi, wi] 表示树中存在一条位于节点 ui 和节点 vi 之间、权重为 wi 的边。

另给你一个长度为 m 的二维整数数组 queries ，其中 queries[i] = [ai, bi] 。对于每条查询，请你找出使从 ai 到 bi 路径上每条边的权重相等所需的 最小操作次数 。在一次操作中，你可以选择树上的任意一条边，并将其权重更改为任意值。

注意：

• 查询之间 相互独立 的，这意味着每条新的查询时，树都会回到 初始状态 。

• 从 ai 到 bi的路径是一个由 不同 节点组成的序列，从节点 ai 开始，到节点 bi 结束，且序列中相邻的两个节点在树中共享一条边。

返回一个长度为 m 的数组 answer ，其中 answer[i] 是第 i 条查询的答案。

示例 1：

```txt

输入：n = 7, edges = [[0,1,1],[1,2,1],[2,3,1],[3,4,2],[4,5,2],[5,6,2]], queries = [[0,3],[3,6],[2,6],[0,6]]

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

解释：第 1 条查询，从节点 0 到节点 3 的路径中的所有边的权重都是 1 。因此，答案为 0 。

第 2 条查询，从节点 3 到节点 6 的路径中的所有边的权重都是 2 。因此，答案为 0 。

第 3 条查询，将边 [2,3] 的权重变更为 2 。在这次操作之后，从节点 2 到节点 6 的路径中的所有边的权重都是 2 。因此，答案为 1 。

第 4 条查询，将边 [0,1]、[1,2]、[2,3] 的权重变更为 2 。在这次操作之后，从节点 0 到节点 6 的路径中的所有边的权重都是 2 。因此，答案为 3 。

对于每条查询 queries[i] ，可以证明 answer[i] 是使从 ai 到 bi 的路径中的所有边的权重相等的最小操作次数。

```

示例 2：

```txt

输入：n = 8, edges = [[1,2,6],[1,3,4],[2,4,6],[2,5,3],[3,6,6],[3,0,8],[7,0,2]], queries = [[4,6],[0,4],[6,5],[7,4]]

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

解释：第 1 条查询，将边 [1,3] 的权重变更为 6 。在这次操作之后，从节点 4 到节点 6 的路径中的所有边的权重都是 6 。因此，答案为 1 。

第 2 条查询，将边 [0,3]、[3,1] 的权重变更为 6 。在这次操作之后，从节点 0 到节点 4 的路径中的所有边的权重都是 6 。因此，答案为 2 。

第 3 条查询，将边 [1,3]、[5,2] 的权重变更为 6 。在这次操作之后，从节点 6 到节点 5 的路径中的所有边的权重都是 6 。因此，答案为 2 。

第 4 条查询，将边 [0,7]、[0,3]、[1,3] 的权重变更为 6 。在这次操作之后，从节点 7 到节点 4 的路径中的所有边的权重都是 6 。因此，答案为 3 。

对于每条查询 queries[i] ，可以证明 answer[i] 是使从 ai 到 bi 的路径中的所有边的权重相等的最小操作次数。

```

提示：

• 1 <= n <= 10^4

• edges.length == n - 1

• edges[i].length == 3

• 0 <= ui, vi < n

• 1 <= wi <= 26

• 生成的输入满足 edges 表示一棵有效的树

• 1 <= queries.length == m <= 2 * 10^4

• queries[i].length == 2

• 0 <= ai, bi < n

6340. 统计上升四元组

给你一个长度为 n 下标从 0 开始的整数数组 nums ，它包含 1 到 n 的所有数字，请你返回上升四元组的数目。

如果一个四元组 (i, j, k, l) 满足以下条件，我们称它是上升的：

• 0 <= i < j < k < l < n 且

• nums[i] < nums[k] < nums[j] < nums[l] 。

示例 1：

```txt

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

输出：2

解释：

• 当 i = 0 ，j = 1 ，k = 2 且 l = 3 时，有 nums[i] < nums[k] < nums[j] < nums[l] 。

• 当 i = 0 ，j = 1 ，k = 2 且 l = 4 时，有 nums[i] < nums[k] < nums[j] < nums[l] 。

没有其他的四元组，所以我们返回 2 。

```

示例 2：

```txt

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

输出：0

解释：只存在一个四元组 i = 0 ，j = 1 ，k = 2 ，l = 3 ，但是 nums[j] < nums[k] ，所以我们返回 0 。

```

提示：

• 4 <= nums.length <= 4000

• 1 <= nums[i] <= nums.length

• nums 中所有数字 互不相同 ，nums 是一个排列。

2949. 统计美丽子字符串 II

You are given a string s and a positive integer k.

Let vowels and consonants be the number of vowels and consonants in a string.

A string is beautiful if:

• vowels == consonants.

• (vowels * consonants) % k == 0, in other terms the multiplication of vowels and consonants is divisible by k.

Return the number of non-empty beautiful substrings in the given string s.

A substring is a contiguous sequence of characters in a string.

Vowel letters in English are 'a', 'e', 'i', 'o', and 'u'.

Consonant letters in English are every letter except vowels.

Example 1:

```txt

Input: s = "baeyh", k = 2

Output: 2

Explanation: There are 2 beautiful substrings in the given string.

• Substring "baeyh", vowels = 2 (["a",e"]), consonants = 2 (["y","h"]).

You can see that string "aeyh" is beautiful as vowels == consonants and vowels * consonants % k == 0.

• Substring "baeyh", vowels = 2 (["a",e"]), consonants = 2 (["b","y"]).

You can see that string "baey" is beautiful as vowels == consonants and vowels * consonants % k == 0.

It can be shown that there are only 2 beautiful substrings in the given string.

```

Example 2:

```txt

Input: s = "abba", k = 1

Output: 3

Explanation: There are 3 beautiful substrings in the given string.

• Substring "abba", vowels = 1 (["a"]), consonants = 1 (["b"]).

• Substring "abba", vowels = 1 (["a"]), consonants = 1 (["b"]).

• Substring "abba", vowels = 2 (["a","a"]), consonants = 2 (["b","b"]).

It can be shown that there are only 3 beautiful substrings in the given string.

```

Example 3:

```txt

Input: s = "bcdf", k = 1

Output: 0

Explanation: There are no beautiful substrings in the given string.

```

Constraints:

• 1 <= s.length <= 5 * 10^4

• 1 <= k <= 1000

• s consists of only English lowercase letters.

6392. 使数组所有元素变成 1 的最少操作次数

给你一个下标从 0 开始的 正 整数数组 nums 。你可以对数组执行以下操作 任意 次：

• 选择一个满足 0 <= i < n - 1 的下标 i ，将 nums[i] 或者 nums[i+1] 两者之一替换成它们的最大公约数。

请你返回使数组 nums 中所有元素都等于 1 的 最少 操作次数。如果无法让数组全部变成 1 ，请你返回 -1 。

两个正整数的最大公约数指的是能整除这两个数的最大正整数。

示例 1：

```txt

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

输出：4

解释：我们可以执行以下操作：

• 选择下标 i = 2 ，将 nums[2] 替换为 gcd(3,4) = 1 ，得到 nums = [2,6,1,4] 。

• 选择下标 i = 1 ，将 nums[1] 替换为 gcd(6,1) = 1 ，得到 nums = [2,1,1,4] 。

• 选择下标 i = 0 ，将 nums[0] 替换为 gcd(2,1) = 1 ，得到 nums = [1,1,1,4] 。

• 选择下标 i = 2 ，将 nums[3] 替换为 gcd(1,4) = 1 ，得到 nums = [1,1,1,1] 。

```

示例 2：

```txt

输入：nums = [2,10,6,14]

输出：-1

解释：无法将所有元素都变成 1 。

```

提示：

• 2 <= nums.length <= 50

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

6423. 英雄的力量

给你一个下标从 0 开始的整数数组 nums ，它表示英雄的能力值。如果我们选出一部分英雄，这组英雄的 力量 定义为：

• i0 ，i1 ，... ik 表示这组英雄在数组中的下标。那么这组英雄的力量为 max(nums[i0],nums[i1] ... nums[ik])^2 * min(nums[i0],nums[i1] ... nums[ik]) 。

请你返回所有可能的 非空 英雄组的 力量 之和。由于答案可能非常大，请你将结果对 10^9 + 7 取余。

示例 1：

```txt

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

输出：141

解释：

第 1 组：[2] 的力量为 22 * 2 = 8 。

第 2 组：[1] 的力量为 12 * 1 = 1 。

第 3 组：[4] 的力量为 42 * 4 = 64 。

第 4 组：[2,1] 的力量为 22 * 1 = 4 。

第 5 组：[2,4] 的力量为 42 * 2 = 32 。

第 6 组：[1,4] 的力量为 42 * 1 = 16 。

第​ ​​​​​​7 组：[2,1,4] 的力量为 42​​​​​​​ * 1 = 16 。

所有英雄组的力量之和为 8 + 1 + 64 + 4 + 32 + 16 + 16 = 141 。

```

示例 2：

```txt

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

输出：7

解释：总共有 7 个英雄组，每一组的力量都是 1 。所以所有英雄组的力量之和为 7 。

```

提示：

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

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