【LeetCode双周赛】第 114 场双周赛

2869. 收集元素的最少操作次数 简单

给你一个正整数数组 nums 和一个整数 k 。

一次操作中，你可以将数组的最后一个元素删除，将该元素添加到一个集合中。

请你返回收集元素 1, 2, …, k 需要的 最少操作次数 。

示例 1：

输入：nums = [3,1,5,4,2], k = 2
输出：4
解释：4 次操作后，集合中的元素依次添加了 2 ，4 ，5 和 1 。此时集合中包含元素 1 和 2 ，所以答案为 4 。

示例 2：

输入：nums = [3,1,5,4,2], k = 5
输出：5
解释：5 次操作后，集合中的元素依次添加了 2 ，4 ，5 ，1 和 3 。此时集合中包含元素 1 到 5 ，所以答案为 5 。

示例 3：

输入：nums = [3,2,5,3,1], k = 3
输出：4
解释：4 次操作后，集合中的元素依次添加了 1 ，3 ，5 和 2 。此时集合中包含元素 1 到 3 ，所以答案为 4 。

提示：

• $1<=nums.length<=50$
• $1<=nums[i]<=nums.length$
• $1<=k<=nums.length$
• 输入保证你可以收集到元素 1, 2, …, k 。

分析：
简单的模拟。
从后往前进行数字的删除，直到1~k的所有数字都从数组中删除，及删除结束。

代码：

class Solution {
public:
    int minOperations(vector<int>& nums, int k) {
        if(nums.size()==k) return k;
        int flag[55],index=nums.size()-1;
        memset(flag,0,sizeof(flag));
        while(index>=0){
            flag[nums[index]]=1; 
            int i=1;
            for(;i<=k;i++){
                if(flag[i]==0) break;
            }
            if(i>k) return nums.size()-index;
            index--;
        }
        return nums.size();
    }
};

2870. 使数组为空的最少操作次数 中等

给你一个下标从 0 开始的正整数数组 nums 。

你可以对数组执行以下两种操作 任意次 ：

从数组中选择 两个 值 相等 的元素，并将它们从数组中 删除 。
从数组中选择 三个 值 相等 的元素，并将它们从数组中 删除 。
请你返回使数组为空的 最少 操作次数，如果无法达成，请返回 -1 。

示例 1：

输入：nums = [2,3,3,2,2,4,2,3,4]
输出：4
解释：我们可以执行以下操作使数组为空：

• 对下标为 0 和 3 的元素执行第一种操作，得到 nums = [3,3,2,4,2,3,4] 。
• 对下标为 2 和 4 的元素执行第一种操作，得到 nums = [3,3,4,3,4] 。
• 对下标为 0 ，1 和 3 的元素执行第二种操作，得到 nums = [4,4] 。
• 对下标为 0 和 1 的元素执行第一种操作，得到 nums = [] 。
  至少需要 4 步操作使数组为空。

示例 2：

输入：nums = [2,1,2,2,3,3]
输出：-1
解释：无法使数组为空。

提示：

• $2<=nums.length<=10^5$
• $1<=nums[i]<=10^6$

分析：
统计每个数在数组中的出现次数。
使用贪心策略，尽量每个数都多使用 三个同时消除，同时保证剩下的数能用两个同时消除消干净。
统计消除的次数。

代码：

class Solution {
public:
    int minOperations(vector<int>& nums) {
        unordered_map<int, int> m;
        int ans=0;
        for(int i=0;i<nums.size();i++){
            m[nums[i]]++;
        }
        for(auto& a : m){
            if(a.second==1) return -1;
            int t=a.second/3,tt=a.second-t*3;
            while(tt%2!=0){
                t--;tt+=3;
            }
            ans+=(t+tt/2);
        }
        return ans;
    }
};

2871. 将数组分割成最多数目的子数组 中等

给你一个只包含 非负 整数的数组 nums 。

我们定义满足 l <= r 的子数组 nums[l..r] 的分数为 nums[l] AND nums[l + 1] AND ... AND nums[r] ，其中 AND 是按位与运算。

请你将数组分割成一个或者更多子数组，满足：

每个 元素都 只 属于一个子数组。
子数组分数之和尽可能 小 。
请你在满足以上要求的条件下，返回 最多 可以得到多少个子数组。

一个 子数组 是一个数组中一段连续的元素。

示例 1：

输入：nums = [1,0,2,0,1,2]
输出：3
解释：我们可以将数组分割成以下子数组：

• [1,0] 。子数组分数为 1 AND 0 = 0 。
• [2,0] 。子数组分数为 2 AND 0 = 0 。
• [1,2] 。子数组分数为 1 AND 2 = 0 。
  分数之和为 0 + 0 + 0 = 0 ，是我们可以得到的最小分数之和。
  在分数之和为 0 的前提下，最多可以将数组分割成 3 个子数组。所以> 返回 3 。

示例 2：

输入：nums = [5,7,1,3]
输出：1
解释：我们可以将数组分割成一个子数组：[5,7,1,3] ，分数为 1 ，这 > 是可以得到的最小总分数。
在总分数为 1 的前提下，最多可以将数组分割成 1 个子数组。所以返回 1 。

提示：

• $1<=nums.length<=10^5$
• $0<=nums[i]<=10^6$

分析：
本题主要用到的思想：

• AND也就是按位与，越多数字按位与，那最终结果会越来越小。
• 子数组按位与的结果只会小于等于整个数组的按位与的结果。

利用贪心策略，当子数组按位与结果为0，就进行分割，直至最后所有子数组分配完毕。如果最后一个子数组按位与的结果大于0，则将其与前一个子数组合并，最终结果都为0。
如果不能得到按位与结果为0的数组，那就不用划分子数组。如果整个数组所有数字按位与结果大于0，那划分子数组得到的按位与结果之和会更大。

代码：

class Solution {
public:
    int maxSubarrays(vector<int>& nums) {
        int ans=0, a=-1;
        for(int num : nums){
            a &= num;
            if(a==0) ans++,a=-1;
        }
        return ans>0?ans:1;
    }
};

tips：根据题解，可以利用 $-1\&a=a$ 的性质来作为原始值。