fork()==0世界线变动

1453. 圆形靶内的最大飞镖数量

墙壁上挂着一个圆形的飞镖靶。现在请你蒙着眼睛向靶上投掷飞镖。

投掷到墙上的飞镖用二维平面上的点坐标数组表示。飞镖靶的半径为 r 。

请返回能够落在 任意 半径为 r 的圆形靶内或靶上的最大飞镖数。

示例 1：

```txt

输入：points = [[-2,0],[2,0],[0,2],[0,-2]], r = 2

输出：4

解释：如果圆形的飞镖靶的圆心为 (0,0) ，半径为 2 ，所有的飞镖都落在靶上，此时落在靶上的飞镖数最大，值为 4 。

```

示例 2：

```txt

输入：points = [[-3,0],[3,0],[2,6],[5,4],[0,9],[7,8]], r = 5

输出：5

解释：如果圆形的飞镖靶的圆心为 (0,4) ，半径为 5 ，则除了 (7,8) 之外的飞镖都落在靶上，此时落在靶上的飞镖数最大，值为 5 。

```

示例 3：

```txt

输入：points = [[-2,0],[2,0],[0,2],[0,-2]], r = 1

输出：1

```

示例 4：

```txt

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

输出：4

```

提示：

• 1 <= points.length <= 100

• points[i].length == 2

• -10^4 <= points[i][0], points[i][1] <= 10^4

• 1 <= r <= 5000

963. 最小面积矩形 II

给定在 xy 平面上的一组点，确定由这些点组成的任何矩形的最小面积，其中矩形的边不一定平行于 x 轴和 y 轴。

如果没有任何矩形，就返回 0。

示例 1：

```txt

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

输出：2.00000

解释：最小面积的矩形出现在 [1,2],[2,1],[1,0],[0,1] 处，面积为 2。

```

示例 2：

```txt

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

输出：1.00000

解释：最小面积的矩形出现在 [1,0],[1,1],[2,1],[2,0] 处，面积为 1。

```

示例 3：

```txt

输入：[[0,3],[1,2],[3,1],[1,3],[2,1]]

输出：0

解释：没法从这些点中组成任何矩形。

```

示例 4：

```txt

输入：[[3,1],[1,1],[0,1],[2,1],[3,3],[3,2],[0,2],[2,3]]

输出：2.00000

解释：最小面积的矩形出现在 [2,1],[2,3],[3,3],[3,1] 处，面积为 2。

```

提示：

1. 1 <= points.length <= 50

2. 0 <= points[i][0] <= 40000

3. 0 <= points[i][1] <= 40000

4. 所有的点都是不同的。

5. 与真实值误差不超过 10^-5 的答案将视为正确结果。

2584. 分割数组使乘积互质

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

如果在下标 i 处 分割 数组，其中 0 <= i <= n - 2 ，使前 i + 1 个元素的乘积和剩余元素的乘积互质，则认为该分割 有效 。

• 例如，如果 nums = [2, 3, 3] ，那么在下标 i = 0 处的分割有效，因为 2 和 9 互质，而在下标 i = 1 处的分割无效，因为 6 和 3 不互质。在下标 i = 2 处的分割也无效，因为 i == n - 1 。

返回可以有效分割数组的最小下标 i ，如果不存在有效分割，则返回 -1 。

当且仅当 gcd(val1, val2) == 1 成立时，val1 和 val2 这两个值才是互质的，其中 gcd(val1, val2) 表示 val1 和 val2 的最大公约数。

示例 1：

```txt

输入：nums = [4,7,8,15,3,5]

输出：2

解释：上表展示了每个下标 i 处的前 i + 1 个元素的乘积、剩余元素的乘积和它们的最大公约数的值。

唯一一个有效分割位于下标 2 。

```

示例 2：

```txt

输入：nums = [4,7,15,8,3,5]

输出：-1

解释：上表展示了每个下标 i 处的前 i + 1 个元素的乘积、剩余元素的乘积和它们的最大公约数的值。

不存在有效分割。

```

提示：

• n == nums.length

• 1 <= n <= 10^4

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

1157. 子数组中占绝大多数的元素

设计一个数据结构，有效地找到给定子数组的 多数元素 。

子数组的 多数元素 是在子数组中出现 threshold 次数或次数以上的元素。

实现 MajorityChecker 类:

• MajorityChecker(int[] arr) 会用给定的数组 arr 对 MajorityChecker 初始化。

• int query(int left, int right, int threshold) 返回子数组中的元素  arr[left...right] 至少出现 threshold 次数，如果不存在这样的元素则返回 -1。

示例 1：

```txt

输入:

["MajorityChecker", "query", "query", "query"]

[[[1, 1, 2, 2, 1, 1]], [0, 5, 4], [0, 3, 3], [2, 3, 2]]

输出：

[null, 1, -1, 2]

解释：

MajorityChecker majorityChecker = new MajorityChecker([1,1,2,2,1,1]);

majorityChecker.query(0,5,4); // 返回 1

majorityChecker.query(0,3,3); // 返回 -1

majorityChecker.query(2,3,2); // 返回 2

```

提示：

• 1 <= arr.length <= 2 * 10^4

• 1 <= arr[i] <= 2 * 10^4

• 0 <= left <= right < arr.length

• threshold <= right - left + 1

• 2 * threshold > right - left + 1

• 调用 query 的次数最多为 10^4

2543. 判断一个点是否可以到达

给你一个无穷大的网格图。一开始你在 (1, 1) ，你需要通过有限步移动到达点 (targetX, targetY) 。

每一步 ，你可以从点 (x, y) 移动到以下点之一：

• (x, y - x)

• (x - y, y)

• (2 * x, y)

• (x, 2 * y)

给你两个整数 targetX 和 targetY ，分别表示你最后需要到达点的 X 和 Y 坐标。如果你可以从 (1, 1) 出发到达这个点，请你返回true ，否则返回 false 。

示例 1：

```txt

输入：targetX = 6, targetY = 9

输出：false

解释：没法从 (1,1) 出发到达 (6,9) ，所以返回 false 。

```

示例 2：

```txt

输入：targetX = 4, targetY = 7

输出：true

解释：你可以按照以下路径到达：(1,1) -> (1,2) -> (1,4) -> (1,8) -> (1,7) -> (2,7) -> (4,7) 。

```

提示：

• 1 <= targetX, targetY <= 10^9

1819. 序列中不同最大公约数的数目

给你一个由正整数组成的数组 nums 。

数字序列的 最大公约数 定义为序列中所有整数的共有约数中的最大整数。

• 例如，序列 [4,6,16] 的最大公约数是 2 。

数组的一个 子序列 本质是一个序列，可以通过删除数组中的某些元素（或者不删除）得到。

• 例如，[2,5,10] 是 [1,2,1,**2**,4,1,**5**,**10**] 的一个子序列。

计算并返回 nums 的所有 非空 子序列中 不同 最大公约数的 数目 。

示例 1：

```txt

输入：nums = [6,10,3]

输出：5

解释：上图显示了所有的非空子序列与各自的最大公约数。

不同的最大公约数为 6 、10 、3 、2 和 1 。

```

示例 2：

```txt

输入：nums = [5,15,40,5,6]

输出：7

```

提示：

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

• 1 <= nums[i] <= 2 * 10^5

2183. 统计可以被 K 整除的下标对数目

给你一个下标从 0 开始、长度为 n 的整数数组 nums 和一个整数 k ，返回满足下述条件的下标对 (i, j) 的数目：

• 0 <= i < j <= n - 1 且

• nums[i] * nums[j] 能被 k 整除。

示例 1：

```txt

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

输出：7

解释：

共有 7 对下标的对应积可以被 2 整除：

(0, 1)、(0, 3)、(1, 2)、(1, 3)、(1, 4)、(2, 3) 和 (3, 4)

它们的积分别是 2、4、6、8、10、12 和 20 。

其他下标对，例如 (0, 2) 和 (2, 4) 的乘积分别是 3 和 15 ，都无法被 2 整除。

```

示例 2：

```txt

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

输出：0

解释：不存在对应积可以被 5 整除的下标对。

```

提示：

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

• 1 <= nums[i], k <= 10^5