力扣leetcode第 280 场周赛

Posted 2022-02-21 狗蛋儿l

得到 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 的 操作数 。

输入：num1 = 2, num2 = 3 输出：3 解释：

• 操作 1 ：num1 = 2 ，num2 = 3 。由于 num1 < num2 ，num2 减 num1 得到 num1 = 2 ，num2 = 3 - 2 = 1 。
• 操作 2 ：num1 = 2 ，num2 = 1 。由于 num1 > num2 ，num1 减 num2 。
• 操作 3 ：num1 = 1 ，num2 = 1 。由于 num1 == num2 ，num1 减 num2 。 此时 num1 = 0 ，num2 = 1 。由于 num1 == 0 ，不需要再执行任何操作。 所以总操作数是 3 。

输入：num1 = 10, num2 = 10 输出：1 解释：

• 操作 1 ：num1 = 10 ，num2 = 10 。由于 num1 == num2 ，num1 减 num2 得到 num1 = 10 - 10 = 0 。 此时 num1 = 0 ，num2 = 10 。由于 num1 == 0 ，不需要再执行任何操作。
  所以总操作数是 1 。

0 <= num1, num2 <= 105

class Solution 
public:
    int countOperations(int num1, int num2) 
        int ans=0;
        while(num1&&num2)
        
            if(num1>num2)
            
                num1-=num2;
                ans++;
            
            else 
            
                num2-=num1;
                ans++;
            
        
        return ans;
    
;

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

给你一个下标从 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] 更改 为 任一 正整数。
返回使数组变成交替数组的 最少操作数 。

示例 1：

输入：nums = [3,1,3,2,4,3] 输出：3 解释： 使数组变成交替数组的方法之一是将该数组转换为 [3,1,3,1,3,1]
。 在这种情况下，操作数为 3 。 可以证明，操作数少于 3 的情况下，无法使数组变成交替数组。

示例 2：

输入：nums = [1,2,2,2,2] 输出：2 解释： 使数组变成交替数组的方法之一是将该数组转换为 [1,2,1,2,1].
在这种情况下，操作数为 2 。 注意，数组不能转换成 [2,2,2,2,2] 。因为在这种情况下，nums[0] ==
nums[1]，不满足交替数组的条件。

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

class Solution 
public:
    int minimumOperations(vector<int>& nums) 
        int n = nums.size();
        unordered_map<int, int> odd, even;
        for(int i = 0; i < n; i ++)
        
            if(i % 2 == 1) odd[nums[i]] ++;
            else even[nums[i]] ++;
        

        // 在奇数下标内统计：
        // x0 - x1: 出现次数最多x1的数x0
        // x_ - x2: 出现次数次多x2的数x_
        // y同理
        int x0 = -1, x_ = -1, x1 = 0, x2 = 0;  
        int y0 = -1, y_ = -1, y1 = 0, y2 = 0;

        for(auto x : odd)
        
            int num = x.first, cnt = x.second;
            if(cnt > x1)
            
                x1 = cnt;
                x0 = num;
            
        

        for(auto x : odd)
        
            int num = x.first, cnt = x.second;
            if(cnt <= x1 && num != x0)
            
                if(cnt > x2)
                
                    x2 = cnt;
                    x_ = num;
                
            
        

        for(auto y : even)
        
            int num = y.first, cnt = y.second;
            if(cnt > y1)
            
                y1 = cnt;
                y0 = num;
            
        

        for(auto y : even)
        
            int num = y.first, cnt = y.second;
            if(cnt <= y1 && num != y0)
            
                if(cnt > y2)
                
                    y2 = cnt;
                    y_ = num;
                
            
        

        if(x0 != y0) return n - x1 - y1;
        else return min(n - x1 - y2, n - x2 - y1);
    
;

拿出最少数目的魔法豆

给你一个 正 整数数组 beans ，其中每个整数表示一个袋子里装的魔法豆的数目。
请你从每个袋子中 拿出 一些豆子（也可以 不拿出），使得剩下的 非空 袋子中（即 至少 还有 一颗 魔法豆的袋子）魔法豆的数目 相等 。一旦魔法豆从袋子中取出，你不能将它放到任何其他的袋子中。
请你返回你需要拿出魔法豆的 最少数目。

示例 1：

输入：beans = [4,1,6,5] 输出：4 解释：

• 我们从有 1 个魔法豆的袋子中拿出 1 颗魔法豆。 剩下袋子中魔法豆的数目为：[4,0,6,5]
• 然后我们从有 6 个魔法豆的袋子中拿出 2 个魔法豆。 剩下袋子中魔法豆的数目为：[4,0,4,5]
• 然后我们从有 5 个魔法豆的袋子中拿出 1 个魔法豆。 剩下袋子中魔法豆的数目为：[4,0,4,4] 总共拿出了 1 + 2 + 1 = 4 个魔法豆，剩下非空袋子中魔法豆的数目相等。 没有比取出 4 个魔法豆更少的方案。

示例 2：

输入：beans = [2,10,3,2] 输出：7 解释：

• 我们从有 2 个魔法豆的其中一个袋子中拿出 2 个魔法豆。 剩下袋子中魔法豆的数目为：[0,10,3,2]
• 然后我们从另一个有 2 个魔法豆的袋子中拿出 2 个魔法豆。 剩下袋子中魔法豆的数目为：[0,10,3,0]
• 然后我们从有 3 个魔法豆的袋子中拿出 3 个魔法豆。 剩下袋子中魔法豆的数目为：[0,10,0,0] 总共拿出了 2 + 2 + 3 = 7 个魔法豆，剩下非空袋子中魔法豆的数目相等。 没有比取出 7 个魔法豆更少的方案。

1 <= beans.length <= 105
1 <= beans[i] <= 105

class Solution 
public:
    long long minimumRemoval(vector<int>& beans) 
        int n = beans.size();
        sort(beans.begin(),beans.end());
        long long prefixSum[n];
        prefixSum[0] = beans[0];
        for(int i = 1; i < n;++i)prefixSum[i] = prefixSum[i-1] + beans[i];
        long long res = (prefixSum[n-1] - prefixSum[0]) - (long long)beans[0] * (n-1);
        for(int i = 1; i < n;++i)
            //以当前位置为最终结果的话，左边所有的位置都得减为0
            res = min(prefixSum[i-1] + (prefixSum[n-1] - prefixSum[i]) - (long long)(n-i-1) * beans[i],res);
        
        return res;
    
;

数组的最大与和

给你一个长度为 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 个篮子中的最大与和。

示例 1：

输入：nums = [1,2,3,4,5,6], numSlots = 3 输出：9 解释：一个可行的方案是 [1, 4] 放入篮子 1 中，[2, 6] 放入篮子 2 中，[3, 5] 放入篮子 3 中。 最大与和为 (1 AND 1) + (4 AND 1) + (2 AND 2) + (6 AND 2) + (3 AND 3) + (5 AND 3) = 1 + 0 + 2 + 2 + 3 + 1 = 9。

示例 2：

输入：nums = [1,3,10,4,7,1], numSlots = 9 输出：24 解释：一个可行的方案是 [1, 1] 放入篮子 1
中，[3] 放入篮子 3 中，[4] 放入篮子 4 中，[7] 放入篮子 7 中，[10] 放入篮子 9 中。 最大与和为 (1 AND 1) + (1 AND 1) + (3 AND 3) + (4 AND 4) + (7 AND 7) + (10 AND 9) = 1 +1 + 3 + 4 + 7 + 8 = 24 。 注意，篮子 2 ，5 ，6 和 8 是空的，这是允许的。

n == nums.length
1 <= numSlots <= 9
1 <= n <= 2 * numSlots
1 <= nums[i] <= 15

class Solution 
public:
    int maximumANDSum(vector<int>& nums, int s) 
        int n = nums.size(), M = 1;
        
        for(int i = 0; i < s; ++i) M *= 3;
        
        int f[n + 1][M];
        
        memset(f, 0, sizeof(f));
        
        for(int i = 1; i <= n; ++i) 
            for(int j = 0; j < M; ++j) 
                int t = j, w = 1;
                for(int k = 1; k <= s; ++k) 
                    if(t % 3) 
                        f[i][j] = max(f[i][j], f[i-1][j - w] + (k & nums[i-1]));
                    
                    t /= 3;
                    w *= 3;
                
            
        
        
        return f[n][M-1];
    
;