双周赛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 <= 501 <= 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 <= 1050 <= nums[i] <= 1060 <= 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 <= 10151 <= limit <= 91 <= s.length <= floor(log10(finish)) + 1s数位中每个数字都小于等于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);
}
/**
不考虑前导0
limitLow 表示第 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 或 hi
int 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);
}
/**
不考虑前导0
limitLow 表示第 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 或 hi
int 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;
}
}
考虑前导0模板