fork()==0世界线变动

6367. 求出最多标记下标

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

一开始，所有下标都没有被标记。你可以执行以下操作任意次：

• 选择两个 互不相同且未标记 的下标 i 和 j ，满足 2 * nums[i] <= nums[j] ，标记下标 i 和 j 。

请你执行上述操作任意次，返回 nums 中最多可以标记的下标数目。

示例 1：

```txt

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

输出：2

解释：第一次操作中，选择 i = 2 和 j = 1 ，操作可以执行的原因是 2 * nums[2] <= nums[1] ，标记下标 2 和 1 。

没有其他更多可执行的操作，所以答案为 2 。

```

示例 2：

```txt

输入：nums = [9,2,5,4]

输出：4

解释：第一次操作中，选择 i = 3 和 j = 0 ，操作可以执行的原因是 2 * nums[3] <= nums[0] ，标记下标 3 和 0 。

第二次操作中，选择 i = 1 和 j = 2 ，操作可以执行的原因是 2 * nums[1] <= nums[2] ，标记下标 1 和 2 。

没有其他更多可执行的操作，所以答案为 4 。

```

示例 3：

```txt

输入：nums = [7,6,8]

输出：0

解释：没有任何可以执行的操作，所以答案为 0 。

```

提示：

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

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

878. 第 N 个神奇数字

一个正整数如果能被 a 或 b 整除，那么它是神奇的。

给定三个整数 n , a , b ，返回第 n 个神奇的数字。因为答案可能很大，所以返回答案 对 10^9 + 7 取模 后的值。

示例 1：

```txt

输入：n = 1, a = 2, b = 3

输出：2

```

示例 2：

```txt

输入：n = 4, a = 2, b = 3

输出：6

```

提示：

• 1 <= n <= 10^9

• 2 <= a, b <= 4 * 10^4

6355. 统计公平数对的数目

给你一个下标从 0 开始、长度为 n 的整数数组 nums ，和两个整数 lower 和 upper ，返回 公平数对的数目 。

如果 (i, j) 数对满足以下情况，则认为它是一个 公平数对 ：

• 0 <= i < j < n，且

• lower <= nums[i] + nums[j] <= upper

示例 1：

```txt

输入：nums = [0,1,7,4,4,5], lower = 3, upper = 6

输出：6

解释：共计 6 个公平数对：(0,3)、(0,4)、(0,5)、(1,3)、(1,4) 和 (1,5) 。

```

示例 2：

```txt

输入：nums = [1,7,9,2,5], lower = 11, upper = 11

输出：1

解释：只有单个公平数对：(2,3) 。

```

提示：

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

• nums.length == n

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

• -10^9 <= lower <= upper <= 10^9

2250. 统计包含每个点的矩形数目

给你一个二维整数数组 rectangles ，其中 rectangles[i] = [li, hi] 表示第 i 个矩形长为 li 高为 hi 。给你一个二维整数数组 points ，其中 points[j] = [xj, yj] 是坐标为 (xj, yj) 的一个点。

第 i 个矩形的 左下角 在 (0, 0) 处，右上角 在 (li, hi) 。

请你返回一个整数数组 count ，长度为 points.length，其中 count[j]是 包含 第 j 个点的矩形数目。

如果 0 <= xj <= li 且 0 <= yj <= hi ，那么我们说第 i 个矩形包含第 j 个点。如果一个点刚好在矩形的 边上 ，这个点也被视为被矩形包含。

示例 1：

```txt

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

输出：[2,1]

解释：

第一个矩形不包含任何点。

第二个矩形只包含一个点 (2, 1) 。

第三个矩形包含点 (2, 1) 和 (1, 4) 。

包含点 (2, 1) 的矩形数目为 2 。

包含点 (1, 4) 的矩形数目为 1 。

所以，我们返回 [2, 1] 。

```

示例 2：

```txt

输入：rectangles = [[1,1],[2,2],[3,3]], points = [[1,3],[1,1]]

输出：[1,3]

解释：

第一个矩形只包含点 (1, 1) 。

第二个矩形只包含点 (1, 1) 。

第三个矩形包含点 (1, 3) 和 (1, 1) 。

包含点 (1, 3) 的矩形数目为 1 。

包含点 (1, 1) 的矩形数目为 3 。

所以，我们返回 [1, 3] 。

```

提示：

• 1 <= rectangles.length, points.length <= 5 * 10^4

• rectangles[i].length == points[j].length == 2

• 1 <= li, xj <= 10^9

• 1 <= hi, yj <= 100

• 所有 rectangles 互不相同 。

• 所有 points 互不相同 。

1760. 袋子里最少数目的球

给你一个整数数组 nums ，其中 nums[i] 表示第 i 个袋子里球的数目。同时给你一个整数 maxOperations 。

你可以进行如下操作至多 maxOperations 次：

• 选择任意一个袋子，并将袋子里的球分到 2 个新的袋子中，每个袋子里都有 正整数 个球。

  • 比方说，一个袋子里有 5 个球，你可以把它们分到两个新袋子里，分别有 1 个和 4 个球，或者分别有 2 个和 3 个球。

你的开销是单个袋子里球数目的 最大值 ，你想要 最小化 开销。

请你返回进行上述操作后的最小开销。

示例 1：

```txt

输入：nums = [9], maxOperations = 2

输出：3

解释：

• 将装有 9 个球的袋子分成装有 6 个和 3 个球的袋子。[9] -> [6,3] 。

• 将装有 6 个球的袋子分成装有 3 个和 3 个球的袋子。[6,3] -> [3,3,3] 。

装有最多球的袋子里装有 3 个球，所以开销为 3 并返回 3 。

```

示例 2：

```txt

输入：nums = [2,4,8,2], maxOperations = 4

输出：2

解释：

• 将装有 8 个球的袋子分成装有 4 个和 4 个球的袋子。[2,4,8,2] -> [2,4,4,4,2] 。

• 将装有 4 个球的袋子分成装有 2 个和 2 个球的袋子。[2,4,4,4,2] -> [2,2,2,4,4,2] 。

• 将装有 4 个球的袋子分成装有 2 个和 2 个球的袋子。[2,2,2,4,4,2] -> [2,2,2,2,2,4,2] 。

• 将装有 4 个球的袋子分成装有 2 个和 2 个球的袋子。[2,2,2,2,2,4,2] -> [2,2,2,2,2,2,2,2] 。

装有最多球的袋子里装有 2 个球，所以开销为 2 并返回 2 。

```

示例 3：

```txt

输入：nums = [7,17], maxOperations = 2

输出：7

```

提示：

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

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

1889. 装包裹的最小浪费空间

给你 n 个包裹，你需要把它们装在箱子里，每个箱子装一个包裹。总共有 m 个供应商提供 不同尺寸 的箱子（每个规格都有无数个箱子）。如果一个包裹的尺寸 小于等于 一个箱子的尺寸，那么这个包裹就可以放入这个箱子之中。

包裹的尺寸用一个整数数组 packages 表示，其中 packages[i] 是第 i 个包裹的尺寸。供应商用二维数组 boxes 表示，其中 boxes[j] 是第 j 个供应商提供的所有箱子尺寸的数组。

你想要选择 一个供应商 并只使用该供应商提供的箱子，使得 总浪费空间最小 。对于每个装了包裹的箱子，我们定义 浪费的 空间等于 箱子的尺寸 - 包裹的尺寸 。总浪费空间 为 所有 箱子中浪费空间的总和。

• 比方说，如果你想要用尺寸数组为 [4,8] 的箱子装下尺寸为 [2,3,5] 的包裹，你可以将尺寸为 2 和 3 的两个包裹装入两个尺寸为 4 的箱子中，同时把尺寸为 5 的包裹装入尺寸为 8 的箱子中。总浪费空间为 (4-2) + (4-3) + (8-5) = 6 。

请你选择 最优 箱子供应商，使得 总浪费空间最小 。如果 无法 将所有包裹放入箱子中，请你返回 -1 。由于答案可能会 很大 ，请返回它对 10^9 + 7 取余 的结果。

示例 1：

```txt

输入：packages = [2,3,5], boxes = [[4,8],[2,8]]

输出：6

解释：选择第一个供应商最优，用两个尺寸为 4 的箱子和一个尺寸为 8 的箱子。

总浪费空间为 (4-2) + (4-3) + (8-5) = 6 。

```

示例 2：

```txt

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

输出：-1

解释：没有箱子能装下尺寸为 5 的包裹。

```

示例 3：

```txt

输入：packages = [3,5,8,10,11,12], boxes = [[12],[11,9],[10,5,14]]

输出：9

解释：选择第三个供应商最优，用两个尺寸为 5 的箱子，两个尺寸为 10 的箱子和两个尺寸为 14 的箱子。

总浪费空间为 (5-3) + (5-5) + (10-8) + (10-10) + (14-11) + (14-12) = 9 。

```

提示：

• n == packages.length

• m == boxes.length

• 1 <= n <= 10^5

• 1 <= m <= 10^5

• 1 <= packages[i] <= 10^5

• 1 <= boxes[j].length <= 10^5

• 1 <= boxes[j][k] <= 10^5

• sum(boxes[j].length) <= 10^5

• boxes[j] 中的元素 互不相同 。

2258. 逃离火灾

给你一个下标从 0 开始大小为 m x n 的二维整数数组 grid ，它表示一个网格图。每个格子为下面 3 个值之一：

• 0 表示草地。

• 1 表示着火的格子。

• 2 表示一座墙，你跟火都不能通过这个格子。

一开始你在最左上角的格子 (0, 0) ，你想要到达最右下角的安全屋格子 (m - 1, n - 1) 。每一分钟，你可以移动到 相邻 的草地格子。每次你移动 之后 ，着火的格子会扩散到所有不是墙的 相邻 格子。

请你返回你在初始位置可以停留的 最多 分钟数，且停留完这段时间后你还能安全到达安全屋。如果无法实现，请你返回 -1 。如果不管你在初始位置停留多久，你 总是 能到达安全屋，请你返回 10^9 。

注意，如果你到达安全屋后，火马上到了安全屋，这视为你能够安全到达安全屋。

如果两个格子有共同边，那么它们为 相邻 格子。

示例 1：

```txt

输入：grid = [[0,2,0,0,0,0,0],[0,0,0,2,2,1,0],[0,2,0,0,1,2,0],[0,0,2,2,2,0,2],[0,0,0,0,0,0,0]]

输出：3

解释：上图展示了你在初始位置停留 3 分钟后的情形。

你仍然可以安全到达安全屋。

停留超过 3 分钟会让你无法安全到达安全屋。

```

示例 2：

```txt

输入：grid = [[0,0,0,0],[0,1,2,0],[0,2,0,0]]

输出：-1

解释：上图展示了你马上开始朝安全屋移动的情形。

火会蔓延到你可以移动的所有格子，所以无法安全到达安全屋。

所以返回 -1 。

```

示例 3：

```txt

输入：grid = [[0,0,0],[2,2,0],[1,2,0]]

输出：1000000000

解释：上图展示了初始网格图。

注意，由于火被墙围了起来，所以无论如何你都能安全到达安全屋。

所以返回 109 。

```

提示：

• m == grid.length

• n == grid[i].length

• 2 <= m, n <= 300

• 4 <= m * n <= 2 * 10^4

• grid[i][j] 是 0 ，1 或者 2 。

• grid[0][0] == grid[m - 1][n - 1] == 0