fork()==0世界线变动

1824. 最少侧跳次数

给你一个长度为 n 的 3 跑道道路 ，它总共包含 n + 1 个 点 ，编号为 0 到 n 。一只青蛙从 0 号点第二条跑道 出发 ，它想要跳到点 n 处。然而道路上可能有一些障碍。

给你一个长度为 n + 1 的数组 obstacles ，其中 obstacles[i] （取值范围从 0 到 3）表示在点 i 处的 obstacles[i] 跑道上有一个障碍。如果 obstacles[i] == 0 ，那么点 i 处没有障碍。任何一个点的三条跑道中 最多有一个 障碍。

• 比方说，如果 obstacles[2] == 1 ，那么说明在点 2 处跑道 1 有障碍。

这只青蛙从点 i 跳到点 i + 1 且跑道不变的前提是点 i + 1 的同一跑道上没有障碍。为了躲避障碍，这只青蛙也可以在 同一个 点处 侧跳 到 另外一条 跑道（这两条跑道可以不相邻），但前提是跳过去的跑道该点处没有障碍。

• 比方说，这只青蛙可以从点 3 处的跑道 3 跳到点 3 处的跑道 1 。

这只青蛙从点 0 处跑道 2 出发，并想到达点 n 处的 任一跑道 ，请你返回 最少侧跳次数 。

注意：点 0 处和点 n 处的任一跑道都不会有障碍。

示例 1：

```txt

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

输出：2

解释：最优方案如上图箭头所示。总共有 2 次侧跳（红色箭头）。

注意，这只青蛙只有当侧跳时才可以跳过障碍（如上图点 2 处所示）。

```

示例 2：

```txt

输入：obstacles = [0,1,1,3,3,0]

输出：0

解释：跑道 2 没有任何障碍，所以不需要任何侧跳。

```

示例 3：

```txt

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

输出：2

解释：最优方案如上图所示。总共有 2 次侧跳。

```

提示：

• obstacles.length == n + 1

• 1 <= n <= 5 * 10^5

• 0 <= obstacles[i] <= 3

• obstacles[0] == obstacles[n] == 0

2167. 移除所有载有违禁货物车厢所需的最少时间

给你一个下标从 0 开始的二进制字符串 s ，表示一个列车车厢序列。s[i] = '0' 表示第 i 节车厢 不 含违禁货物，而 s[i] = '1' 表示第 i 节车厢含违禁货物。

作为列车长，你需要清理掉所有载有违禁货物的车厢。你可以不限次数执行下述三种操作中的任意一个：

1. 从列车 左 端移除一节车厢（即移除 s[0]），用去 1 单位时间。

2. 从列车 右 端移除一节车厢（即移除 s[s.length - 1]），用去 1 单位时间。

3. 从列车车厢序列的 任意位置 移除一节车厢，用去 2 单位时间。

返回移除所有载有违禁货物车厢所需要的 最少 单位时间数。

注意，空的列车车厢序列视为没有车厢含违禁货物。

示例 1：

```txt

输入：s = "1100101"

输出：5

解释：

一种从序列中移除所有载有违禁货物的车厢的方法是：

• 从左端移除一节车厢 2 次。所用时间是 2 * 1 = 2 。

• 从右端移除一节车厢 1 次。所用时间是 1 。

• 移除序列中间位置载有违禁货物的车厢。所用时间是 2 。

总时间是 2 + 1 + 2 = 5 。

一种替代方法是：

• 从左端移除一节车厢 2 次。所用时间是 2 * 1 = 2 。

• 从右端移除一节车厢 3 次。所用时间是 3 * 1 = 3 。

总时间也是 2 + 3 = 5 。

5 是移除所有载有违禁货物的车厢所需要的最少单位时间数。

没有其他方法能够用更少的时间移除这些车厢。

```

示例 2：

```txt

输入：s = "0010"

输出：2

解释：

一种从序列中移除所有载有违禁货物的车厢的方法是：

• 从左端移除一节车厢 3 次。所用时间是 3 * 1 = 3 。

总时间是 3.

另一种从序列中移除所有载有违禁货物的车厢的方法是：

• 移除序列中间位置载有违禁货物的车厢。所用时间是 2 。

总时间是 2.

另一种从序列中移除所有载有违禁货物的车厢的方法是：

• 从右端移除一节车厢 2 次。所用时间是 2 * 1 = 2 。

总时间是 2.

2 是移除所有载有违禁货物的车厢所需要的最少单位时间数。

没有其他方法能够用更少的时间移除这些车厢。

```

提示：

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

• s[i] 为 '0' 或 '1'

2484. 统计回文子序列数目

给你数字字符串 s ，请你返回 s 中长度为 5 的 回文子序列 数目。由于答案可能很大，请你将答案对 10^9 + 7 取余 后返回。

提示：

• 如果一个字符串从前往后和从后往前读相同，那么它是 回文字符串 。

• 子序列是一个字符串中删除若干个字符后，不改变字符顺序，剩余字符构成的字符串。

示例 1：

```txt

输入：s = "103301"

输出：2

解释：

总共有 6 长度为 5 的子序列："10330" ，"10331" ，"10301" ，"10301" ，"13301" ，"03301" 。

它们中有两个（都是 "10301"）是回文的。

```

示例 2：

```txt

输入：s = "0000000"

输出：21

解释：所有 21 个长度为 5 的子序列都是 "00000" ，都是回文的。

```

示例 3：

```txt

输入：s = "9999900000"

输出：2

解释：仅有的两个回文子序列是 "99999" 和 "00000" 。

```

提示：

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

• s 只包含数字字符。

6352. 美丽子集的数目

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

如果 nums 的子集中，任意两个整数的绝对差均不等于 k ，则认为该子数组是一个 美丽 子集。

返回数组 nums 中 非空 且 美丽 的子集数目。

nums 的子集定义为：可以经由 nums 删除某些元素（也可能不删除）得到的一个数组。只有在删除元素时选择的索引不同的情况下，两个子集才会被视作是不同的子集。

示例 1：

```txt

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

输出：4

解释：数组 nums 中的美丽子集有：[2], [4], [6], [2, 6] 。

可以证明数组 [2,4,6] 中只存在 4 个美丽子集。

```

示例 2：

```txt

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

输出：1

解释：数组 nums 中的美丽数组有：[1] 。

可以证明数组 [1] 中只存在 1 个美丽子集。

```

提示：

• 1 <= nums.length <= 20

• 1 <= nums[i], k <= 1000

1997. 访问完所有房间的第一天

你需要访问 n 个房间，房间从 0 到 n - 1 编号。同时，每一天都有一个日期编号，从 0 开始，依天数递增。你每天都会访问一个房间。

最开始的第 0 天，你访问 0 号房间。给你一个长度为 n 且 下标从 0 开始 的数组 nextVisit 。在接下来的几天中，你访问房间的 次序 将根据下面的 规则 决定：

• 假设某一天，你访问 i 号房间。

• 如果算上本次访问，访问 i 号房间的次数为 奇数 ，那么 第二天 需要访问 nextVisit[i] 所指定的房间，其中 0 <= nextVisit[i] <= i 。

• 如果算上本次访问，访问 i 号房间的次数为 偶数 ，那么 第二天 需要访问 (i + 1) mod n 号房间。

请返回你访问完所有房间的第一天的日期编号。题目数据保证总是存在这样的一天。由于答案可能很大，返回对 10^9 + 7 取余后的结果。

示例 1：

```txt

输入：nextVisit = [0,0]

输出：2

解释：

• 第 0 天，你访问房间 0 。访问 0 号房间的总次数为 1 ，次数为奇数。

下一天你需要访问房间的编号是 nextVisit[0] = 0

• 第 1 天，你访问房间 0 。访问 0 号房间的总次数为 2 ，次数为偶数。

下一天你需要访问房间的编号是 (0 + 1) mod 2 = 1

• 第 2 天，你访问房间 1 。这是你第一次完成访问所有房间的那天。

```

示例 2：

```txt

输入：nextVisit = [0,0,2]

输出：6

解释：

你每天访问房间的次序是 [0,0,1,0,0,1,2,...] 。

第 6 天是你访问完所有房间的第一天。

```

示例 3：

```txt

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

输出：6

解释：

你每天访问房间的次序是 [0,0,1,1,2,2,3,...] 。

第 6 天是你访问完所有房间的第一天。

```

提示：

• n == nextVisit.length

• 2 <= n <= 10^5

• 0 <= nextVisit[i] <= i

6987. 使数组和小于等于 x 的最少时间

给你两个长度相等下标从 0 开始的整数数组 nums1 和 nums2 。每一秒，对于所有下标 0 <= i < nums1.length ，nums1[i] 的值都增加 nums2[i] 。操作 完成后 ，你可以进行如下操作：

• 选择任一满足 0 <= i < nums1.length 的下标 i ，并使 nums1[i] = 0 。

同时给你一个整数 x 。

请你返回使 nums1 中所有元素之和 小于等于 x 所需要的 最少 时间，如果无法实现，那么返回 -1 。

示例 1：

```txt

输入：nums1 = [1,2,3], nums2 = [1,2,3], x = 4

输出：3

解释：

第 1 秒，我们对 i = 0 进行操作，得到 nums1 = [0,2+2,3+3] = [0,4,6] 。

第 2 秒，我们对 i = 1 进行操作，得到 nums1 = [0+1,0,6+3] = [1,0,9] 。

第 3 秒，我们对 i = 2 进行操作，得到 nums1 = [1+1,0+2,0] = [2,2,0] 。

现在 nums1 的和为 4 。不存在更少次数的操作，所以我们返回 3 。

```

示例 2：

```txt

输入：nums1 = [1,2,3], nums2 = [3,3,3], x = 4

输出：-1

解释：不管如何操作，nums1 的和总是会超过 x 。

```

提示：

• 1 <= nums1.length <= 10^3

• 1 <= nums1[i] <= 10^3

• 0 <= nums2[i] <= 10^3

• nums1.length == nums2.length

• 0 <= x <= 10^6

2902. 和带限制的子多重集合的数目

给你一个下标从 0 开始的非负整数数组 nums 和两个整数 l 和 r 。

请你返回 nums 中子多重集合的和在闭区间 [l, r] 之间的 子多重集合的数目 。

由于答案可能很大，请你将答案对 10^9 + 7 取余后返回。

子多重集合 指的是从数组中选出一些元素构成的 无序 集合，每个元素 x 出现的次数可以是 0, 1, ..., occ[x] 次，其中 occ[x] 是元素 x 在数组中的出现次数。

注意：

• 如果两个子多重集合中的元素排序后一模一样，那么它们两个是相同的 子多重集合 。

• 空 集合的和是 0 。

示例 1：

```txt

输入：nums = [1,2,2,3], l = 6, r = 6

输出：1

解释：唯一和为 6 的子集合是 {1, 2, 3} 。

```

示例 2：

```txt

输入：nums = [2,1,4,2,7], l = 1, r = 5

输出：7

解释：和在闭区间 [1, 5] 之间的子多重集合为 {1} ，{2} ，{4} ，{2, 2} ，{1, 2} ，{1, 4} 和 {1, 2, 2} 。

```

示例 3：

```txt

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

输出：9

解释：和在闭区间 [3, 5] 之间的子多重集合为 {3} ，{5} ，{1, 2} ，{1, 3} ，{2, 2} ，{2, 3} ，{1, 1, 2} ，{1, 1, 3} 和 {1, 2, 2} 。

```

提示：

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

• 0 <= nums[i] <= 2 * 10^4

• nums 的和不超过 2 * 10^4 。

• 0 <= l <= r <= 2 * 10^4