20220911- LC第310场周赛

最新推荐文章于 2022-09-20 18:13:17 发布

另一种开始

最新推荐文章于 2022-09-20 18:13:17 发布

阅读量785

点赞数

文章标签： leetcode 算法职场和发展

本文链接：https://blog.csdn.net/tracker647/article/details/126804666

版权

本文探讨了三个与数据结构和算法相关的编程问题：1) 寻找最频繁出现的偶数；2) 字符串的最优划分；3) 将区间划分为最少组数。对于第一个问题，通过排序和哈希映射找到出现频率最高的偶数；第二个问题采用贪心策略，避免滑动窗口；第三个问题利用优先队列解决区间不相交的分组问题。这些解决方案展示了在处理不同问题时如何选择合适的数据结构和算法策略。

摘要由CSDN通过智能技术生成

20220911- LC第310场周赛

讨论：https://leetcode.cn/circle/discuss/s55Iwu/

6176. 出现最频繁的偶数元素（AC）

给你一个整数数组 nums ，返回出现最频繁的偶数元素。

如果存在多个满足条件的元素，只需要返回最小的一个。如果不存在这样的元素，返回 -1 。

示例 1：

输入：nums = [0,1,2,2,4,4,1]
输出：2
解释：
数组中的偶数元素为 0、2 和 4 ，在这些元素中，2 和 4 出现次数最多。
返回最小的那个，即返回 2 。
示例 2：

输入：nums = [4,4,4,9,2,4]
输出：4
解释：4 是出现最频繁的偶数元素。
示例 3：

输入：nums = [29,47,21,41,13,37,25,7]
输出：-1
解释：不存在偶数元素。

提示：

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

思路：排成逆序后遍历哈希表计数

class Solution {
public:
    int mostFrequentEven(vector<int>& nums) {
        sort(nums.begin(),nums.end(),greater<int>());
        unordered_map<int,int> cnt;
        int maxCnt = 0;
        int res = -1;
        for(int i : nums){
            cnt[i]++;
            if(i % 2 == 0 && cnt[i] >= maxCnt){
                maxCnt = cnt[i];
                res = i;
            }
        }
        return res;
    }
};

6177. 子字符串的最优划分

给你一个字符串 s ，请你将该字符串划分成一个或多个子字符串，并满足每个子字符串中的字符都是唯一的。也就是说，在单个子字符串中，字母的出现次数都不超过一次。

满足题目要求的情况下，返回最少需要划分多少个子字符串。

注意，划分后，原字符串中的每个字符都应该恰好属于一个子字符串。

示例 1：

输入：s = “abacaba”
输出：4
解释：
两种可行的划分方法分别是 (“a”,“ba”,“cab”,“a”) 和 (“ab”,“a”,“ca”,“ba”) 。
可以证明最少需要划分 4 个子字符串。
示例 2：

输入：s = “ssssss”
输出：6
解释：
只存在一种可行的划分方法 (“s”,“s”,“s”,“s”,“s”,“s”) 。

提示：

1 <= s.length <= 105
s 仅由小写英文字母组成

思路：以为是滑动窗口，完全想不到是贪心，估计是惯性思维。

int partitionString(string s) {
        unordered_map<char,int> umap;
        int res = 1;
        for(char c : s){
            umap[c]++;
            if(umap[c] > 1){
                res++;
                umap.clear();
                umap[c] = 1;
            }
        }

        return res;
    }

6178. 将区间分为最少组数

给你一个二维整数数组 intervals ，其中 intervals[i] = [lefti, righti] 表示闭区间 [lefti, righti] 。

你需要将 intervals 划分为一个或者多个区间组，每个区间只属于一个组，且同一个组中任意两个区间不相交。

请你返回最少需要划分成多少个组。

如果两个区间覆盖的范围有重叠（即至少有一个公共数字），那么我们称这两个区间是相交的。比方说区间 [1, 5] 和 [5, 8] 相交。

示例 1：

输入：intervals = [[5,10],[6,8],[1,5],[2,3],[1,10]]
输出：3
解释：我们可以将区间划分为如下的区间组：

第 1 组：[1, 5] ，[6, 8] 。
第 2 组：[2, 3] ，[5, 10] 。
第 3 组：[1, 10] 。
可以证明无法将区间划分为少于 3 个组。
示例 2：

输入：intervals = [[1,3],[5,6],[8,10],[11,13]]
输出：1
解释：所有区间互不相交，所以我们可以把它们全部放在一个组内。

提示：

1 <= intervals.length <= 105
intervals[i].length == 2
1 <= lefti <= righti <= 106

思路：

熟悉的区间类问题，完全想不到用优先队列可以分组，有些类似于253会议室问题，还是做太少了。

static bool cmp(vector<int> &lhs, vector<int> &rhs){
        return lhs[0] < rhs[0];
    }
    int minGroups(vector<vector<int>>& inv) {
        sort(inv.begin(), inv.end(), cmp);
        //用一个优先队列维护每个组最大的终点
        priority_queue<int, vector<int>, greater<int>> pq; 
        pq.push(inv[0][1]);
        for(int i = 1; i < inv.size(); i++){
            //发生重叠，新增组终点
            if(pq.top() >= inv[i][0]){
                pq.push(inv[i][1]);
            }
            //没发生重叠，更新当前组终点
            else{
                pq.pop();
                pq.push(inv[i][1]);
            }
        }

        return pq.size();
    }