双周赛121（模拟、位运算、BFS、数位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 。

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

1. 如果 x 是 11 的倍数，将 x 除以 11 。
2. 如果 x 是 5 的倍数，将 x 除以 5 。
3. 将 x 减 1 。
4. 将 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);
    }

    /**
    不考虑前导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模板