fork()==0世界线变动

2581. 统计可能的树根数目

Alice 有一棵 n 个节点的树，节点编号为 0 到 n - 1 。树用一个长度为 n - 1 的二维整数数组 edges 表示，其中 edges[i] = [ai, bi] ，表示树中节点 ai 和 bi 之间有一条边。

Alice 想要 Bob 找到这棵树的根。她允许 Bob 对这棵树进行若干次 猜测 。每一次猜测，Bob 做如下事情：

• 选择两个 不相等 的整数 u 和 v ，且树中必须存在边 [u, v] 。

• Bob 猜测树中 u 是 v 的 父节点 。

Bob 的猜测用二维整数数组 guesses 表示，其中 guesses[j] = [uj, vj] 表示 Bob 猜 uj 是 vj 的父节点。

Alice 非常懒，她不想逐个回答 Bob 的猜测，只告诉 Bob 这些猜测里面 至少 有 k 个猜测的结果为 true 。

给你二维整数数组 edges ，Bob 的所有猜测和整数 k ，请你返回可能成为树根的 节点数目 。如果没有这样的树，则返回 0。

示例 1：

```txt

输入：edges = [[0,1],[1,2],[1,3],[4,2]], guesses = [[1,3],[0,1],[1,0],[2,4]], k = 3

输出：3

解释：

根为节点 0 ，正确的猜测为 [1,3], [0,1], [2,4]

根为节点 1 ，正确的猜测为 [1,3], [1,0], [2,4]

根为节点 2 ，正确的猜测为 [1,3], [1,0], [2,4]

根为节点 3 ，正确的猜测为 [1,0], [2,4]

根为节点 4 ，正确的猜测为 [1,3], [1,0]

节点 0 ，1 或 2 为根时，可以得到 3 个正确的猜测。

```

示例 2：

```txt

输入：edges = [[0,1],[1,2],[2,3],[3,4]], guesses = [[1,0],[3,4],[2,1],[3,2]], k = 1

输出：5

解释：

根为节点 0 ，正确的猜测为 [3,4]

根为节点 1 ，正确的猜测为 [1,0], [3,4]

根为节点 2 ，正确的猜测为 [1,0], [2,1], [3,4]

根为节点 3 ，正确的猜测为 [1,0], [2,1], [3,2], [3,4]

根为节点 4 ，正确的猜测为 [1,0], [2,1], [3,2]

任何节点为根，都至少有 1 个正确的猜测。

```

提示：

• edges.length == n - 1

• 2 <= n <= 10^5

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

• 0 <= ai, bi, uj, vj <= n - 1

• ai != bi

• uj != vj

• edges 表示一棵有效的树。

• guesses[j] 是树中的一条边。

• guesses 是唯一的。

• 0 <= k <= guesses.length

1494. 并行课程 II

给你一个整数 n 表示某所大学里课程的数目，编号为 1 到 n ，数组 relations 中， relations[i] = [xi, yi]  表示一个先修课的关系，也就是课程 xi 必须在课程 yi 之前上。同时你还有一个整数 k 。

在一个学期中，你 最多 可以同时上 k 门课，前提是这些课的先修课在之前的学期里已经上过了。

请你返回上完所有课最少需要多少个学期。题目保证一定存在一种上完所有课的方式。

示例 1：

```txt

输入：n = 4, relations = [[2,1],[3,1],[1,4]], k = 2

输出：3

解释：上图展示了题目输入的图。在第一个学期中，我们可以上课程 2 和课程 3 。然后第二个学期上课程 1 ，第三个学期上课程 4 。

```

示例 2：

```txt

输入：n = 5, relations = [[2,1],[3,1],[4,1],[1,5]], k = 2

输出：4

解释：上图展示了题目输入的图。一个最优方案是：第一学期上课程 2 和 3，第二学期上课程 4 ，第三学期上课程 1 ，第四学期上课程 5 。

```

示例 3：

```txt

输入：n = 11, relations = [], k = 2

输出：6

```

提示：

• 1 <= n <= 15

• 1 <= k <= n

• 0 <= relations.length <= n * (n-1) / 2

• relations[i].length == 2

• 1 <= xi, yi <= n

• xi != yi

• 所有先修关系都是不同的，也就是说 relations[i] != relations[j] 。

• 题目输入的图是个有向无环图。

1681. 最小不兼容性

给你一个整数数组 nums​​​ 和一个整数 k 。你需要将这个数组划分到 k 个相同大小的子集中，使得同一个子集里面没有两个相同的元素。

一个子集的 不兼容性 是该子集里面最大值和最小值的差。

请你返回将数组分成 k 个子集后，各子集 不兼容性 的 和 的 最小值 ，如果无法分成分成 k 个子集，返回 -1 。

子集的定义是数组中一些数字的集合，对数字顺序没有要求。

示例 1：

```txt

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

输出：4

解释：最优的分配是 [1,2] 和 [1,4] 。

不兼容性和为 (2-1) + (4-1) = 4 。

注意到 [1,1] 和 [2,4] 可以得到更小的和，但是第一个集合有 2 个相同的元素，所以不可行。

```

示例 2：

```txt

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

输出：6

解释：最优的子集分配为 [1,2]，[2,3]，[6,8] 和 [1,3] 。

不兼容性和为 (2-1) + (3-2) + (8-6) + (3-1) = 6 。

```

示例 3：

```txt

输入：nums = [5,3,3,6,3,3], k = 3

输出：-1

解释：没办法将这些数字分配到 3 个子集且满足每个子集里没有相同数字。

```

提示：

• 1 <= k <= nums.length <= 16

• nums.length 能被 k 整除。

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

1595. 连通两组点的最小成本

给你两组点，其中第一组中有 size1 个点，第二组中有 size2 个点，且 size1 >= size2 。

任意两点间的连接成本 cost 由大小为 size1 x size2 矩阵给出，其中 cost[i][j] 是第一组中的点 i 和第二组中的点 j 的连接成本。如果两个组中的每个点都与另一组中的一个或多个点连接，则称这两组点是连通的。换言之，第一组中的每个点必须至少与第二组中的一个点连接，且第二组中的每个点必须至少与第一组中的一个点连接。

返回连通两组点所需的最小成本。

示例 1：

```txt

输入：cost = [[15, 96], [36, 2]]

输出：17

解释：连通两组点的最佳方法是：

1--A

2--B

总成本为 17 。

```

示例 2：

```txt

输入：cost = [[1, 3, 5], [4, 1, 1], [1, 5, 3]]

输出：4

解释：连通两组点的最佳方法是：

1--A

2--B

2--C

3--A

最小成本为 4 。

请注意，虽然有多个点连接到第一组中的点 2 和第二组中的点 A ，但由于题目并不限制连接点的数目，所以只需要关心最低总成本。

```

示例 3：

```txt

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

输出：10

```

提示：

• size1 == cost.length

• size2 == cost[i].length

• 1 <= size1, size2 <= 12

• size1 >= size2

• 0 <= cost[i][j] <= 100

1388. 3n 块披萨

给你一个披萨，它由 3n 块不同大小的部分组成，现在你和你的朋友们需要按照如下规则来分披萨：

• 你挑选 任意 一块披萨。

• Alice 将会挑选你所选择的披萨逆时针方向的下一块披萨。

• Bob 将会挑选你所选择的披萨顺时针方向的下一块披萨。

• 重复上述过程直到没有披萨剩下。

每一块披萨的大小按顺时针方向由循环数组 slices 表示。

请你返回你可以获得的披萨大小总和的最大值。

示例 1：

```txt

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

输出：10

解释：选择大小为 4 的披萨，Alice 和 Bob 分别挑选大小为 3 和 5 的披萨。然后你选择大小为 6 的披萨，Alice 和 Bob 分别挑选大小为 2 和 1 的披萨。你获得的披萨总大小为 4 + 6 = 10 。

```

示例 2：

```txt

输入：slices = [8,9,8,6,1,1]

输出：16

解释：两轮都选大小为 8 的披萨。如果你选择大小为 9 的披萨，你的朋友们就会选择大小为 8 的披萨，这种情况下你的总和不是最大的。

```

提示：

• 1 <= slices.length <= 500

• slices.length % 3 == 0

• 1 <= slices[i] <= 1000

100216. K 个不相交子数组的最大能量值

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

x 个子数组的能量值定义为 strength = sum[1] * x - sum[2] * (x - 1) + sum[3] * (x - 2) - sum[4] * (x - 3) + ... + sum[x] * 1 ，其中 sum[i] 是第 i 个子数组的和。更正式的，能量值是满足 1 <= i <= x 的所有 i 对应的 (-1)^i+1 * sum[i] * (x - i + 1) 之和。

你需要在 nums 中选择 k 个 不相交子数组 ，使得 能量值最大 。

请你返回可以得到的 最大能量值 。

注意，选出来的所有子数组 不 需要覆盖整个数组。

示例 1：

```txt

输入：nums = [1,2,3,-1,2], k = 3

输出：22

解释：选择 3 个子数组的最好方式是选择：nums[0..2] ，nums[3..3] 和 nums[4..4] 。能量值为 (1 + 2 + 3) * 3 - (-1) * 2 + 2 * 1 = 22 。

```

示例 2：

```txt

输入：nums = [12,-2,-2,-2,-2], k = 5

输出：64

解释：唯一一种选 5 个不相交子数组的方案是：nums[0..0] ，nums[1..1] ，nums[2..2] ，nums[3..3] 和 nums[4..4] 。能量值为 12 * 5 - (-2) * 4 + (-2) * 3 - (-2) * 2 + (-2) * 1 = 64 。

```

示例 3：

```txt

输入：nums = [-1,-2,-3], k = 1

输出：-1

解释：选择 1 个子数组的最优方案是：nums[0..0] 。能量值为 -1 。

```

提示：

• 1 <= n <= 10^4

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

• 1 <= k <= n

• 1 <= n * k <= 10^6

• k 是奇数。

1187. 使数组严格递增

给你两个整数数组 arr1 和 arr2，返回使 arr1 严格递增所需要的最小「操作」数（可能为 0）。

每一步「操作」中，你可以分别从 arr1 和 arr2 中各选出一个索引，分别为 i 和 j，0 <= i < arr1.length 和 0 <= j < arr2.length，然后进行赋值运算 arr1[i] = arr2[j]。

如果无法让 arr1 严格递增，请返回 -1。

示例 1：

```txt

输入：arr1 = [1,5,3,6,7], arr2 = [1,3,2,4]

输出：1

解释：用 2 来替换 5，之后 arr1 = [1, 2, 3, 6, 7]。

```

示例 2：

```txt

输入：arr1 = [1,5,3,6,7], arr2 = [4,3,1]

输出：2

解释：用 3 来替换 5，然后用 4 来替换 3，得到 arr1 = [1, 3, 4, 6, 7]。

```

示例 3：

```txt

输入：arr1 = [1,5,3,6,7], arr2 = [1,6,3,3]

输出：-1

解释：无法使 arr1 严格递增。

```

提示：

• 1 <= arr1.length, arr2.length <= 2000

• 0 <= arr1[i], arr2[i] <= 10^9