双周赛121（模拟、位运算、BFS、数位DP上下界）

文章目录

双周赛121
- [2996. 大于等于顺序前缀和的最小缺失整数](https://leetcode.cn/problems/smallest-missing-integer-greater-than-sequential-prefix-sum/)
- - 模拟
- [2997. 使数组异或和等于 K 的最少操作次数](https://leetcode.cn/problems/minimum-number-of-operations-to-make-array-xor-equal-to-k/)
- - 位运算
- [2998. 使 X 和 Y 相等的最少操作次数](https://leetcode.cn/problems/minimum-number-of-operations-to-make-x-and-y-equal/)
- - BFS
- [2999. 统计强大整数的数目](https://leetcode.cn/problems/count-the-number-of-powerful-integers/)
- - 数位DP上下界模板

双周赛121

2996. 大于等于顺序前缀和的最小缺失整数

简单

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

如果一个前缀 nums[0..i] 满足对于 1 <= j <= i 的所有元素都有 nums[j] = nums[j - 1] + 1 ，那么我们称这个前缀是一个 顺序前缀 。特殊情况是，只包含 nums[0] 的前缀也是一个 顺序前缀 。

请你返回 nums 中没有出现过的最小整数 x ，满足 x 大于等于最长顺序前缀的和。

示例 1：

输入：nums = [1,2,3,2,5]
输出：6
解释：nums 的最长顺序前缀是 [1,2,3] ，和为 6 ，6 不在数组中，所以 6 是大于等于最长顺序前缀和的最小整数。

示例 2：

输入：nums = [3,4,5,1,12,14,13]
输出：15
解释：nums 的最长顺序前缀是 [3,4,5] ，和为 12 ，12、13 和 14 都在数组中，但 15 不在，所以 15 是大于等于最长顺序前缀和的最小整数。

提示：

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

模拟

class Solution {public int missingInteger(int[] nums) {Set<Integer> set = new HashSet<>();for(int x : nums) set.add(x);int i = 1, s = nums[0];int n = nums.length;while(i < n && nums[i] == nums[i-1] + 1){s += nums[i];i++;} while(true){if(set.contains(s))s++;else return s;}}
}

2997. 使数组异或和等于 K 的最少操作次数

中等

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

你可以对数组执行以下操作 任意次 ：

选择数组里的任意一个元素，并将它的 二进制 表示翻转一个数位，翻转数位表示将 0 变成 1 或者将 1 变成 0 。

你的目标是让数组里所有元素的按位异或和得到 k ，请你返回达成这一目标的最少操作次数。

注意，你也可以将一个数的前导 0 翻转。比方说，数字 (101)2 翻转第四个数位，得到 (1101)2 。

示例 1：

输入：nums = [2,1,3,4], k = 1
输出：2
解释：我们可以执行以下操作：
- 选择下标为 2 的元素，也就是 3 == (011)2 ，我们翻转第一个数位得到 (010)2 == 2 。数组变为 [2,1,2,4] 。
- 选择下标为 0 的元素，也就是 2 == (010)2 ，我们翻转第三个数位得到 (110)2 == 6 。数组变为 [6,1,2,4] 。
最终数组的所有元素异或和为 (6 XOR 1 XOR 2 XOR 4) == 1 == k 。
无法用少于 2 次操作得到异或和等于 k 。

示例 2：

输入：nums = [2,0,2,0], k = 0
输出：0
解释：数组所有元素的异或和为 (2 XOR 0 XOR 2 XOR 0) == 0 == k 。所以不需要进行任何操作。

提示：

1 <= nums.length <= 105
0 <= nums[i] <= 106
0 <= k <= 106

位运算

class Solution {/**异或可看作不进位加法，统计数组所有元素和的位数1出现的次数然后和 k 每个位相比，不相同则一定要进行操作*/public int minOperations(int[] nums, int k) {int[] cnt = new int[32];for(int x : nums){for(int i = 0; i < 32; i++){if(((x >> i) & 1) == 1)cnt[i] = (cnt[i] + 1) % 2;}}int res = 0;for(int i = 0; i < 32; i++){if(((k >> i) & 1) != cnt[i])res += 1;}return res;}
}

2998. 使 X 和 Y 相等的最少操作次数

中等

给你两个正整数 x 和 y 。

一次操作中，你可以执行以下四种操作之一：

如果 x 是 11 的倍数，将 x 除以 11 。
如果 x 是 5 的倍数，将 x 除以 5 。
将 x 减 1 。
将 x 加 1 。

请你返回让 x 和 y 相等的最少操作次数。

示例 1：

输入：x = 26, y = 1
输出：3
解释：我们可以通过以下操作将 26 变为 1 ：
1. 将 x 减 1
2. 将 x 除以 5
3. 将 x 除以 5
将 26 变为 1 最少需要 3 次操作。

示例 2：

输入：x = 54, y = 2
输出：4
解释：我们可以通过以下操作将 54 变为 2 ：
1. 将 x 加 1
2. 将 x 除以 11
3. 将 x 除以 5
4. 将 x 加 1
将 54 变为 2 最少需要 4 次操作。

示例 3：

输入：x = 25, y = 30
输出：5
解释：我们可以通过以下操作将 25 变为 30 ：
1. 将 x 加 1
2. 将 x 加 1
3. 将 x 加 1
4. 将 x 加 1
5. 将 x 加 1
将 25 变为 30 最少需要 5 次操作。

提示：

1 <= x, y <= 104

BFS

class Solution {public int minimumOperationsToMakeEqual(int x, int y) {boolean[] vis = new boolean[(int)1e5+5];Deque<Integer> dq = new ArrayDeque<>();dq.add(x);int cnt = 0;while(!dq.isEmpty()){int size = dq.size();while(size-- > 0){int p = dq.pollFirst();if(p == y) return cnt;vis[p] = true;if(p % 11 == 0 && !vis[p % 11]){// 如果 x 是 5 的倍数，将 x 「除以」 5 。dq.addLast(p / 11);}if(p % 5 == 0 && !vis[p % 5]){dq.addLast(p / 5);}if(p > 1 && !vis[p-1])dq.addLast(p-1);if(p < (int)1e5 && !vis[p+1])dq.addLast(p+1);}cnt += 1;}return -1;}
}

2999. 统计强大整数的数目

困难

给你三个整数 start ，finish 和 limit 。同时给你一个下标从 0 开始的字符串 s ，表示一个正整数。

如果一个正整数 x 末尾部分是 s （换句话说，s 是 x 的后缀），且 x 中的每个数位至多是 limit ，那么我们称 x 是 强大的 。

请你返回区间 [start..finish] 内强大整数的 总数目 。

如果一个字符串 x 是 y 中某个下标开始（包括 0 ），到下标为 y.length - 1 结束的子字符串，那么我们称 x 是 y 的一个后缀。比方说，25 是 5125 的一个后缀，但不是 512 的后缀。

示例 1：

输入：start = 1, finish = 6000, limit = 4, s = "124"
输出：5
解释：区间 [1..6000] 内的强大数字为 124 ，1124 ，2124 ，3124 和 4124 。这些整数的各个数位都 <= 4 且 "124" 是它们的后缀。注意 5124 不是强大整数，因为第一个数位 5 大于 4 。
这个区间内总共只有这 5 个强大整数。

示例 2：

输入：start = 15, finish = 215, limit = 6, s = "10"
输出：2
解释：区间 [15..215] 内的强大整数为 110 和 210 。这些整数的各个数位都 <= 6 且 "10" 是它们的后缀。
这个区间总共只有这 2 个强大整数。

示例 3：

输入：start = 1000, finish = 2000, limit = 4, s = "3000"
输出：0
解释：区间 [1000..2000] 内的整数都小于 3000 ，所以 "3000" 不可能是这个区间内任何整数的后缀。

提示：

1 <= start <= finish <= 1015
1 <= limit <= 9
1 <= s.length <= floor(log10(finish)) + 1
s 数位中每个数字都小于等于 limit 。
s 不包含任何前导 0 。

数位DP上下界模板

https://leetcode.cn/problems/count-the-number-of-powerful-integers/

不考虑前导0版

class Solution {char[] low, high;long[] memo;char[] s;int limit;public long numberOfPowerfulInt(long start, long finish, int limit, String S) {// 按照要求记录this.limit = limit;this.s = S.toCharArray();// 模板String lowstr = Long.toString(start);String highstr = Long.toString(finish);int n = highstr.length();lowstr = "0".repeat(n - lowstr.length()) + lowstr; // 补前导零，和 high 对齐low = lowstr.toCharArray(); high = highstr.toCharArray();memo = new long[n];Arrays.fill(memo, -1);return f(0, true, true);}/**不考虑前导0limitLow 表示第 i 数位下界是否有约束limitHigh 表示第 i 数位上界是否有约束*/private long f(int i, boolean limitLow, boolean limitHigh){if(i == high.length)return 1;if(!limitLow && !limitHigh && memo[i] >= 0)return memo[i]; // 之前算过// 第 i 个数位可以从 lo 枚举到 hi// 如果对数位还有其它约束，应当只在下面的 for 循环做限制，不应修改 lo 或 hiint lo = limitLow ? low[i] - '0' : 0;int hi = limitHigh ? high[i] - '0' : 9;long res = 0;if(i < high.length - s.length){ // 枚举这个数位填什么for(int d = lo; d <= Math.min(hi, limit); d++){res += f(i+1, limitLow && d==lo, limitHigh && d==hi);}}else{ // 这个数位只能填 s[i-diff] int x = s[i - (high.length - s.length)] - '0';if(lo <= x && x <= Math.min(hi, limit)){res += f(i+1, limitLow && x == lo, limitHigh && x==hi);}}if(!limitLow && !limitHigh)memo[i] = res; // 记忆化(i, false, false)return res;}
}

考虑前导0

不考虑前导0模板

class Solution {char[] low, high;long[] memo;public long numberOfPowerfulInt(long start, long finish, int limit, String S) {// 按照要求记录// 模板String lowstr = Long.toString(start);String highstr = Long.toString(finish);int n = highstr.length();lowstr = "0".repeat(n - lowstr.length()) + lowstr; // 补前导零，和 high 对齐low = lowstr.toCharArray(); high = highstr.toCharArray();memo = new long[n];Arrays.fill(memo, -1);return f(0, true, true);}/**不考虑前导0limitLow 表示第 i 数位下界是否有约束limitHigh 表示第 i 数位上界是否有约束*/private long f(int i, boolean limitLow, boolean limitHigh){if(i == high.length)return 1;if(!limitLow && !limitHigh && memo[i] >= 0)return memo[i]; // 之前算过// 第 i 个数位可以从 lo 枚举到 hi// 如果对数位还有其它约束，应当只在下面的 for 循环做限制，不应修改 lo 或 hiint lo = limitLow ? low[i] - '0' : 0;int hi = limitHigh ? high[i] - '0' : 9;long res = 0;// 在for循环中按照题意要求加入限制for(int d = lo; d <= hi; d++){ // 枚举这个数位填什么res += f(i+1, limitLow && d==lo, limitHigh && d==hi);}if(!limitLow && !limitHigh)memo[i] = res; // 记忆化(i, false, false)return res;}
}