双周赛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 相等的最少操作次数

中等

给你两个正整数 xy

一次操作中,你可以执行以下四种操作之一:

  1. 如果 x11 的倍数,将 x 除以 11
  2. 如果 x5 的倍数,将 x 除以 5
  3. x1
  4. x1

请你返回让 xy 相等的 最少 操作次数。

示例 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. 统计强大整数的数目

困难

给你三个整数 startfinishlimit 。同时给你一个下标从 0 开始的字符串 s ,表示一个 整数。

如果一个 整数 x 末尾部分是 s (换句话说,sx后缀),且 x 中的每个数位至多是 limit ,那么我们称 x强大的

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

如果一个字符串 xy 中某个下标开始(包括 0 ),到下标为 y.length - 1 结束的子字符串,那么我们称 xy 的一个后缀。比方说,255125 的一个后缀,但不是 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模板

你可能感兴趣的:(算法刷题记录,#,LC周赛,宽度优先,算法)