Leetcode第 310 场周赛 补打

​​Leetcode 第310场周赛​​

自己赛后打了一下，记录了一下时间，大概15min A 3题，第四题是写不出来，然后学习了一天线段树（真的强）。
思路：
1、排序后统计偶数的数目
2、遍历扫一遍，用直接用二进制记录是否访问。
3、差分
4、线段树，动态更新，区间（num[i]-k，num[i]-1）查询最大值.

2404. 出现最频繁的偶数元素

class Solution {
public:
    int mostFrequentEven(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        int n = nums.size();
        int num = -1,cnt = 0;
        for(int i=0;i<n;) {
            if(nums[i]%2==0){
                int j = i+1;
                while(j<n&&nums[j]==nums[i]) j++;
                if(j-i>cnt) num = nums[i],cnt = j-i;
                i = j;
            } 
            else {
                i++;
            }
        }
        return num;
    }
};
//18:46-18:52

6177. 子字符串的最优划分

class Solution {
public:
    int partitionString(string s) {
        int ans = 1,val = 0;
        for(int i=0;i<s.size();i++) {
            if((val>>(s[i]-'a'))%2==0) {
                val += (1<<(s[i]-'a')); 
            }
            else {
                val = (1<<(s[i]-'a'));
                ans++;
            }
        }
        return ans;
    }
};
//18:52-18:56

6178. 将区间分为最少组数

class Solution {
public:
    int minGroups(vector<vector<int>>& intervals) {
        map<int,int> mp;
        for(int i=0;i<intervals.size();i++) {
            mp[intervals[i][0]] += 1;
            mp[intervals[i][1]+1] -= 1;
        }
        auto it = mp.begin();
        int ans = 1,dis = 0;
        while(it!=mp.end()) {
            dis += it->second;
            it++;
            ans = max(dis,ans);
        }
        return ans;
    }
};
//18:56-19:01

6206. 最长递增子序列 II

class Solution {
public:
    int lengthOfLIS(vector<int>& nums, int k) {
        int ans = 1;
        for(int i=0; i<nums.size(); i++) {
            int cnt = query(root,0,N,max(0,nums[i]-k),nums[i]-1) + 1;
            update(root,0,N,nums[i],nums[i],cnt);
            ans = max(cnt,ans); 
        }
        return ans;
    }
        struct Node {
        Node *left,*right;
        int val,lazy;
        Node():val(0),lazy(0),left(nullptr),right(nullptr){}
    };
    const int N = 1e9;
    Node *root = new Node();
    void update(Node *node, int start, int end,int l, int r, int val) {
        if(l<=start && r>=end) {
            node->val = val; // 每个节点存的是当前区间的最大值
            node->lazy = val; //懒惰标记，标记该节点下的子节点需要更新，用于遍历到时候在更新，
            return;
        }
        pushDown(node);
        int mid = (start + end) >> 1;// 右移除2
        if(l <= mid) update(node->left, start, mid, l, r, val); //[start,mid] [l,r] 有交集
        if(r > mid) update(node->right, mid+1, end, l, r, val); //[l,r] [mid+1,end] 有交集
        pushUp(node); 
    }
    void pushDown(Node *node) {
        if(node->left==NULL) node->left = new Node();
        if(node->right==NULL) node->right = new Node();
        if(node->lazy==0) return; // 不需要向下更新
        node->left->val = node->lazy;
        node->right->val = node->lazy;
        node->left->lazy = node->lazy; 
        node->right->lazy = node->lazy; 
        node->lazy = 0;
    }
    void pushUp(Node *node) {
        // 每个节点存的是当前区间的最大值
        node->val = max(node->left->val, node->right->val);
    }
    int query(Node *node, int start, int end, int l, int r) {
        if(l<=start && r>=end) return node->val;
        pushDown(node);
        int mid = (start + end) >> 1, ans = 0;
        if(l<=mid) ans = query(node->left,start,mid,l,r);
        if(r>mid) ans = max(query(node->right,mid+1,end,l,r),ans);
        return ans;
    }
};
//19:01-19.09(go out for a while) 19:15-19:34(abandon)