LeetCode第280周赛回顾

6004. 得到 0 的操作数

给你两个 非负 整数 num1 和 num2 。

每一步 操作 中，如果 num1 >= num2 ，你必须用 num1 减 num2 ；否则，你必须用 num2 减 num1 。

例如，num1 = 5 且 num2 = 4 ，应该用 num1 减 num2 ，因此，得到 num1 = 1 和 num2 = 4 。然而，如果 num1 = 4且 num2 = 5 ，一步操作后，得到 num1 = 4 和 num2 = 1 。
返回使 num1 = 0 或 num2 = 0 的 操作数 。

模拟即可

class Solution {
    public int countOperations(int num1, int num2) {
        if(num1==0||num2==0){
            return 0;
        }
        int ans=1;
        if(num1>=num2){
            num1-=num2;
        }else{
            num2-=num1;
        }
        ans+=countOperations(num1,num2);
        return ans;
    }
}

---

6005. 使数组变成交替数组的最少操作数

给你一个下标从 0 开始的数组 nums ，该数组由 n 个正整数组成。

如果满足下述条件，则数组 nums 是一个 交替数组 ：

nums[i - 2] == nums[i] ，其中 2 <= i <= n - 1 。
nums[i - 1] != nums[i] ，其中 1 <= i <= n - 1 。
在一步 操作 中，你可以选择下标 i 并将 nums[i] 更改 为 任一 正整数。

返回使数组变成交替数组的 最少操作数 。

统计奇数和偶数位置对应的出现次数最大、次大数字，如果最大数字不相同，采用这些数字，其他数字变换即可答案为len-max1-max2，如果相同，要采用另一个的次大出现次数数字

class Solution {
    public int minimumOperations(int[] nums) {
        int n=nums.length,ans=0;
        if(n==1)return 0;
        int even1=0,even2=0,odd1=0,odd2=0;
        int max1=0,max2=0;
        Map<Integer,Integer>map1=new HashMap<>();
        Map<Integer,Integer>map2=new HashMap<>();
        for(int i=0;i<n;i+=2){
            map1.put(nums[i],map1.getOrDefault(nums[i],0)+1);
        }
        for(int num:map1.keySet()){
            int cnt=map1.get(num);
            if(cnt>even1){
                max1=num;
                even2=even1;
                even1=cnt;        
            }else if(cnt>even2){
                even2=cnt;
            }
        }
        for(int i=1;i<n;i+=2){
            map2.put(nums[i],map2.getOrDefault(nums[i],0)+1);
        }
        for(int num:map2.keySet()){
            int cnt=map2.get(num);
            if(cnt>odd1){
                max2=num;
                odd2=odd1;
                odd1=cnt;        
            }else if(cnt>odd2){
                odd2=cnt;
            }
        }
        if(max1!=max2){
            ans=n-even1-odd1;
        }else{
            if(odd1+even2>even1+odd2){
                System.out.println("使用最大奇数"+odd1+"和次大偶数"+even2);
                ans=n-odd1-even2;
                
            }else{
                System.out.println("使用最大偶数"+even1+"和次大奇数"+odd2);
                ans=n-even1-odd2;
            }
        }
        System.out.println(n);
        return ans;
    }
}

---

 6006. 拿出最少数目的魔法豆

给你一个 正 整数数组 beans ，其中每个整数表示一个袋子里装的魔法豆的数目。

请你从每个袋子中 拿出 一些豆子（也可以 不拿出），使得剩下的 非空 袋子中（即 至少 还有 一颗 魔法豆的袋子）魔法豆的数目 相等 。一旦魔法豆从袋子中取出，你不能将它放到任何其他的袋子中。

请你返回你需要拿出魔法豆的 最少数目。

先排序，然后从前到后遍历，计算以当前袋子为基准(前面全部清空)所需要拿出的豆子数(注意不可能清空最后一个袋子，最后一个袋子做基准一定比清空消耗豆子少),返回拿出魔法豆的最少数目

class Solution {
    public long minimumRemoval(int[] beans) {
        Arrays.sort(beans);
        int n=beans.length;
        if(n==1)return 0;
        long sum=beans[0];
        long[]pre=new long[n];
        pre[0]=(long)beans[0];
        for(int i=1;i<n;i++){
            sum+=(long)beans[i];
        }
        for(int i=0;i<n;i++){
            pre[i]=sum-(long)(n-i)*beans[i];
        }
        Arrays.sort(pre);
        return pre[0];
    }
}

---

6007. 数组的最大与和

给你一个长度为 n 的整数数组 nums 和一个整数 numSlots ，满足2 * numSlots >= n 。总共有 numSlots 个篮子，编号为 1 到 numSlots 。

你需要把所有 n 个整数分到这些篮子中，且每个篮子 至多 有 2 个整数。一种分配方案的 与和 定义为每个数与它所在篮子编号的 按位与运算 结果之和。

比方说，将数字 [1, 3] 放入篮子 1 中，[4, 6] 放入篮子 2 中，这个方案的与和为 (1 AND 1) + (3 AND 1) + (4 AND 2) + (6 AND 2) = 1 + 1 + 0 + 2 = 4 。
请你返回将 nums 中所有数放入 numSlots 个篮子中的最大与和。

这题相当折磨人，我直接化身恶魔，CV了一份题解，学习了状态压缩算法，其实也不是没见过了，就是用二进制数对状态进行压缩即可

class Solution {
    public int maximumANDSum(int[] nums, int numSlots) {
        int ans = 0;
        //需要开一个2^numSlots*2的数组，返回最大值
        int f = new int[1 << (numSlots * 2)];
        for (int i = 0; i < f.length; i++) {
            //计算1的个数
            int c = Integer.bitCount(i);
            //如果越界不考虑
            if (c >= nums.length) continue;
            for (int j = 0; j < numSlots * 2; ++j) {
                if ((i & (1 << j)) == 0) { // 枚举空篮子 j
                    int s = i | (1 << j);
                    f[s] = Math.max(f[s], f[i] + ((j / 2 + 1) & nums[c]));
                    ans = Math.max(ans, f[s]);
                }
            }
        }
        return ans;
    }
}