Leetcode302场周赛

不迷茫的小航

已于 2022-07-18 00:09:21 修改

阅读量223

点赞数 1

文章标签： c++ leetcode

于 2022-07-18 00:06:37 首次发布

本文链接：https://blog.csdn.net/m0_62605130/article/details/125835966

版权

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

给你一个下标从 0 开始的整数数组 nums 。在一步操作中，你可以执行以下步骤：

从 nums 选出两个相等的整数
从 nums 中移除这两个整数，形成一个数对

请你在 nums 上多次执行此操作直到无法继续执行。

返回一个下标从 0 开始、长度为 2 的整数数组 answer 作为答案，其中 answer[0] 是形成的数对数目，answer[1] 是对 nums 尽可能执行上述操作后剩下的整数数目

示例 1：

输入：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 个数字。

解题思路：

简单来说就是给数组里的数字配对，看能有几对同时数一下剩几只单身狗。

开一个哈希表计算每个数字出现的次数，配对数就是除以2下取整，最后单身狗的个数就是数组长度减配对数乘2。

代码：

class Solution {
public:
    vector<int> numberOfPairs(vector<int>& nums) {
        unordered_map<int, int> hash;
        for(auto x:nums) hash[x] ++ ;
        vector<int> res(2);
        for(auto [k,v]: hash)
            res[0] += v / 2;//配对数下取整
        res[1] = nums.size() - res[0] * 2;
        return res;
    }
};

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

给你一个下标从 0 开始的数组 nums ，数组中的元素都是正整数。请你选出两个下标 i 和 j（i != j），且 nums[i] 的数位和与 nums[j] 的数位和相等。

请你找出所有满足条件的下标 i 和 j ，找出并返回 nums[i] + nums[j] 可以得到的最大值。

示例 1：

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

解题思路：

先说一下暴力做法，枚举两个数对，判断数位和是否相等，相等就维护一下答案最大值。暴力时间复杂度n^2，

从后往前考虑，先固定一个数，计算出其各位数之和，之后就是在前面找其数位和相等的数，希望两个数最大，换句话说就是要找到前面数位和相等的数字最大的数，采用哈希表优化，用哈希表存对应数位和的最大值，最后查哈希表就好了，这样时间复杂度减低为nlogn

代码

class Solution {
public:
    int maximumSum(vector<int>& nums) {
      int res = -1;
      unordered_map<int, int> hash;//对应每一个数位和的最大值
      for(auto x: nums) {
          int s = 0,y = x;//s为各位数之和，y为每个数
          while(y) s += y % 10,y /= 10;//计算数位和
          if(hash.count(s)) res = max(res, x + hash[s]);//查找s数位和是否存在，存在就更新答案
          hash[s] = max(hash[s], x);//最后要看一下数位和相等的数字中哪个最大
      }
      return res;
    }
};

第三题：6121. 裁剪数字后查询第 K 小的数字

给你一个下标从 0 开始的字符串数组 nums ，其中每个字符串长度相等且只包含数字。

再给你一个下标从 0 开始的二维整数数组 queries ，其中 queries[i] = [ki, trimi] 。对于每个 queries[i] ，你需要：

    将 nums 中每个数字裁剪到剩下最右边 trimi 个数位。
    在裁剪过后的数字中，找到 nums 中第 ki 小数字对应的下标。如果两个裁剪后数字一样大，那么下标更小的数字视为更小的数字。
    将 nums 中每个数字恢复到原本字符串。

请你返回一个长度与 queries 相等的数组 answer，其中 answer[i]是第 i 次查询的结果。

提示：

    裁剪到剩下 x 个数位的意思是不断删除最左边的数位，直到剩下 x 个数位。
    nums 中的字符串可能会有前导 0 。

示例 1：

输入：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 。

提示：

    1 <= nums.length <= 100
    1 <= nums[i].length <= 100
    nums[i] 只包含数字。
    所有 nums[i].length 的长度相同。
    1 <= queries.length <= 100
    queries[i].length == 2
    1 <= ki <= nums.length
    1 <= trimi <= nums[0].length

解题思路：

看着其实挺难的，但看它的数据范围比较小，所以这里的思路还是暴力。

用一个稳定排序存关键字，利用pair来一个双关键字,第一个关键字是字符串，第二个关键字是下标。

先看代码

class Solution {
public:
    vector<int> smallestTrimmedNumbers(vector<string>& nums, vector<vector<int>>& queries) {
        int n = nums.size(), m = queries.size();//n表示数组长度，m是询问的次数
        vector<pair<string, int>> strs(n);
        for(int i = 0; i < n; i ++ ) strs[i] = {nums[i], i};//枚举各个字符串
        vector<int> res;
        for(auto& q: queries){//在每个询问里对字符串进行排序
            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])//比较一下两个字符的字典序，第一个字符串比较小，返回true
                        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;
    }
};

说一下这里的比较函数，return true 表示的是判断是否把 a 放到 b 的前面

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

给你两个正整数数组 nums 和 numsDivide 。你可以从 nums 中删除任意数目的元素。

请你返回使 nums 中最小元素可以整除 numsDivide 中所有元素的最少删除次数。如果无法得到这样的元素，返回 -1 。

如果 y % x == 0 ，那么我们说整数 x 整除 y

示例 1：

输入：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 是最少删除次数。

提示：

1 <= nums.length, numsDivide.length <= 105
1 <= nums[i], numsDivide[i] <= 109

解题思路：

题目中所说的能整除数组中的所有元素意味着能整除所有元素的最大公约数，所以先求最大公约数，然后往后枚举。

代码实现：

class Solution {
public:
    int gcd(int a, int 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;
        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;
    }
};

哈哈lc302结束