6176. 出现最频繁的偶数元素
给你一个整数数组 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) {
map<int, int> hash;
int maxv = 0;
for(auto c: nums){
if(c%2 == 0){
hash[c]++;
maxv = max(maxv, hash[c]);
}
}
for(auto [k, v]:hash){
if(v == maxv){
return k;
}
}
return -1;
}
};
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 仅由小写英文字母组成
题解：贪心
class Solution {
public:
int partitionString(string s) {
int n = s.size();
set<char> S;
int res = 0;
for(int i=0; i<n; i++){
if(S.count(s[i])){
res++;
S.clear();
}
S.insert(s[i]);
}
res++;
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
题解： 贪心 + 堆
class Solution {
public:
int minGroups(vector<vector<int>>& a) {
sort(a.begin(), a.end());
int n = a.size();
priority_queue<int, vector<int>, greater<int>> heap;
for(int i=0; i<n; i++){
if(heap.empty() || heap.top() >= a[i][0]) heap.push(a[i][1]);
else {
heap.pop();
heap.push(a[i][1]);
}
}
return heap.size();
}
};
6206. 最长递增子序列 II
给你一个整数数组 nums 和一个整数 k 。
找到 nums 中满足以下要求的最长子序列：
子序列 严格递增 子序列中相邻元素的差值 不超过 k 。 请你返回满足上述要求的 最长子序列 的长度。
子序列 是从一个数组中删除部分元素后，剩余元素不改变顺序得到的数组。
示例 1：
输入：nums = [4,2,1,4,3,4,5,8,15], k = 3 输出：5 解释： 满足要求的最长子序列是 [1,3,4,5,8] 。 子序列长度为 5 ，所以我们返回 5 。 注意子序列 [1,3,4,5,8,15] 不满足要求，因为 15 - 8 = 7 大于 3 。 示例 2：
输入：nums = [7,4,5,1,8,12,4,7], k = 5 输出：4 解释： 满足要求的最长子序列是 [4,5,8,12] 。 子序列长度为 4 ，所以我们返回 4 。 示例 3：
输入：nums = [1,5], k = 1 输出：1 解释： 满足要求的最长子序列是 [1] 。 子序列长度为 1 ，所以我们返回 1 。
提示：
1 <= nums.length <= 105
1 <= nums[i], k <= 105
题解：线段树
class Solution {
public:
vector<int> tr;
void modify(int u, int l, int r, int i, int val){
if(l == r){
tr[u] = val;
return;
}
int m = (l+r)/2;
if(i <= m){
modify(u*2, l, m, i, val);
}else{
modify(u*2+1, m+1, r, i, val);
}
tr[u] = max(tr[u*2], tr[u*2+1]);
}
int query(int u, int l, int r, int L, int R){
if(L <= l && r <=R){
return tr[u];
}
int res = 0;
int m = (l+r)/2;
if(L <= m){
res = query(u*2, l, m, L, R);
}
if(R > m){
res = max(res, query(u*2+1, m+1, r, L, R));
}
return res;
}
int lengthOfLIS(vector<int>& nums, int k) {
int u = *max_element(nums.begin(), nums.end());
tr.resize(4*u);
for(auto x : nums){
if(x == 1){
modify(1, 1, u, 1, 1);
}else{
int res = 1 + query(1, 1, u, max(x-k, 1), x-1);
modify(1, 1, u, x, res);
}
}
return tr[1];
}
};
