力扣第302场周赛补题

第一题：数组能形成多少数对

示例

输入：nums = [1,3,2,1,3,2,2]
输出：[3,1]
解释：
nums[0] 和 nums[3] 形成一个数对，并从 nums 中移除，nums = [3,2,3,2,2] 。
nums[0] 和 nums[2] 形成一个数对，并从 nums 中移除，nums = [2,2,2] 。
nums[0] 和 nums[1] 形成一个数对，并从 nums 中移除，nums = [2] 。
无法形成更多数对。总共形成 3 个数对，nums 中剩下 1 个数字。

思路

用哈希表记录每个数字出现的次数，遍历数组即可。

代码

class Solution {
public:
    vector<int> numberOfPairs(vector<int>& nums) {
        unordered_map<int,int> mp;
        for(auto i:nums){
            mp[i]++;
        }
        int res=0,ans=0;
        for(auto [u,v]:mp){
            res+=v/2;//能操作的组数
            ans+=v%2;//能整除就加0 不能整除就加1
        }
        return {res,ans};
    }
};

第二题：数位和相等数对的最大和

示例

输入：nums = [18,43,36,13,7]
输出：54
解释：满足条件的数对 (i, j) 为：
- (0, 2) ，两个数字的数位和都是 9 ，相加得到 18 + 36 = 54 。
- (1, 4) ，两个数字的数位和都是 7 ，相加得到 43 + 7 = 50 。
所以可以获得的最大和是 54 。

思路

用哈希表，mp[s]表示之前出现的数位和为s的最大数字，遍历数组，当哈希表中有与遍历的数 数位和相同的数就更新答案。

代码

class Solution {
public:
    int maximumSum(vector<int>& nums) {
        int res=-1;
        unordered_map<int,int> mp;
        for(auto i:nums){
            int j=i,s=0;
            while(j){
                s+=j%10;//求数位和
                j/=10;
            }
            if(mp.count(s)) res=max(res,i+mp[s]);//计算同数位和数字之和
            mp[s]=max(mp[s],i);//更新目前出现的该数位和下的最大数字
        }
        return res;
    }
};

 

第三题：裁剪数字后查询第k小的数字

示例

输入：nums = ["102","473","251","814"], queries = [[1,1],[2,3],[4,2],[1,2]]
输出：[2,2,1,0]
解释：
1. 裁剪到只剩 1 个数位后，nums = ["2","3","1","4"] 。最小的数字是 1 ，下标为 2 。
2. 裁剪到剩 3 个数位后，nums 没有变化。第 2 小的数字是 251 ，下标为 2 。
3. 裁剪到剩 2 个数位后，nums = ["02","73","51","14"] 。第 4 小的数字是 73 ，下标为 1 。
4. 裁剪到剩 2 个数位后，最小数字是 2 ，下标为 0 。
   注意，裁剪后数字 "02" 值为 2 。

思路

用pair存字符串与对应的下标，排序按字符串从小到大并且下标从小到大来排序即可。

代码

比赛时代码

typedef pair<string,int> PSI;
class Solution {
public:
    vector<int> smallestTrimmedNumbers(vector<string>& nums, vector<vector<int>>& qs) {
        int n=nums.size(),m=nums[0].size();
        int k=qs.size();
        vector<int> res(k);
        for(int i=0;i<qs.size();i++){
            vector<PSI> tmp;
            for(int j=0;j<n;j++){
                string s=nums[j].substr(m-qs[i][1],qs[i][1]);
                tmp.push_back({s,j});
            }
            sort(tmp.begin(),tmp.end());
            res[i]=tmp[qs[i][0]-1].second;
        }
        return res;
    }
};

 赛后优化(比上面那个少用了3/4的时间)

class Solution {
public:
    vector<int> smallestTrimmedNumbers(vector<string>& nums, vector<vector<int>>& qs) {
        int n = nums.size(), m = qs.size();
        vector<pair<string, int>> strs(n);
        for (int i = 0; i < n; i ++ ) strs[i] = {nums[i], i};
        vector<int> res;
        for (auto& q: qs) {
            int k = q[0], trim = q[1];
            sort(strs.begin(), strs.end(), [&](pair<string, int>& a, pair<string, int>& b) {
                for (int i = a.first.size() - trim; i < a.first.size(); i ++ )
                    if (a.first[i] < b.first[i])
                        return true;
                    else if (a.first[i] > b.first[i])
                        return false;
                return a.second < b.second;//在满足字符串从小到大排序的情况下满足下标从小到大
            });
            res.push_back(strs[k - 1].second);
        }
        return res;
    }
};

 

第四题：使数组可以被整除的最少删除次数

示例

输入：nums = [2,3,2,4,3], numsDivide = [9,6,9,3,15]
输出：2
解释：
[2,3,2,4,3] 中最小元素是 2 ，它无法整除 numsDivide 中所有元素。
我们从 nums 中删除 2 个大小为 2 的元素，得到 nums = [3,4,3] 。
[3,4,3] 中最小元素为 3 ，它可以整除 numsDivide 中所有元素。
可以证明 2 是最少删除次数。

思路

先找到目标数组的最大公约数，根据算术基本定理可知，其他约数一定可以整除最大公约数。

代码

class Solution {
public:
    int gcd(int a,int b){
        // if(!b) return a;
        // return gcd(b,a%b);
        return b?gcd(b,a%b):a;
    }
    int minOperations(vector<int>& nums, vector<int>& numsDivide) {
        int d=0;
        for(auto x:numsDivide) d=gcd(d,x);//找所有元素的最大公约数
        int res=0;//“算术基本定理可表述为：任何一个大于1的自然数 N,如果N不为质数，那么N可以唯一分解成有限个质数的乘积”
        //其他约数一定可以整除最大公约数
        sort(nums.begin(),nums.end());
        for(int i=0;i<nums.size();i++){
            if(d%nums[i]==0) break;
            res++;
        }        
        if(res==nums.size()) res=-1;//没有找到满足条件的值
        return res;
    }
};