力扣周赛427😎

力扣周赛427😎

Problem 3 😊

给你一个整数数组 nums 和一个整数 k 。
返回nums中一个非空子数组的最大和要求该子数组的长度可以被k整除。

• 1 <= k <= nums.length <= 2 * 10^5
• -10^9 <= nums[i] <= 10^9

好久不做题目了 啥都想不起来了

• 同余思想加速枚举 因此维护剩余系就好了

class Solution {
public:
    long long maxSubarraySum(vector<int>& nums, int k) {
        int n  = nums.size();
        long long s[int(1e6+10)];
        s[0] = 0;
        for(int i=1;i<=n;i++)s[i] = s[i-1] + nums[i-1];
        map<int,long long>mp;
        const long long inf = 1e15;
        for(int i=0;i<k;++i)mp[i] = inf;
        long long ans = -inf;
        for(int i=1;i<=n;i++){
            auto t = i%k;
            if(mp[t]!=inf)ans = max(ans,s[i]-mp[t]);
            if(t==0)ans = max(ans,s[i]);
            mp[t] = min(mp[t],s[i]);
        }

        return ans;


    }
};

Poblem 4😒

二维数点 典题

~~ 看了讲解还写了2钟头... ~~
各种细节问题都容易犯 尤其是离散化不去重~~

写写还是不错的 捡起来了很多遗忘的知识

class Fenwick {
    vector<int> tree;

public:
    Fenwick(int n) : tree(n+10, 0) {}

    void add(int i) {
        while (i < tree.size()) {
            tree[i]++;
            i += i & -i;
        }
    }

    // [1,i] 中的元素和
    int pre(int i) {
        int res = 0;
        while (i > 0) {
            res += tree[i];
            i -= i & -i;
        }
        return res;
    }

    // [l,r] 中的元素和
    int query(int l, int r) {
        return pre(r) - pre(l - 1);
    }
};
class Solution {
public:
    long long maxRectangleArea(vector<int>& xCoord, vector<int>& yCoord) {
        unordered_map<int,vector<int>>x_map;//同一竖线下的点的纵坐标
        unordered_map<int,vector<int>>y_map;//同一横线下的点的横坐标

        for(int i=0;i<xCoord.size();++i){
            auto x = xCoord[i],y = yCoord[i];
            x_map[x].push_back(y);
            y_map[y].push_back(x);
        }

        //处理每个点左边的点
        unordered_map<long long,int>left;

        for(auto &[y,x_list]:y_map){
            sort(x_list.begin(),x_list.end());
            for(int i=1;i<x_list.size();++i){
                auto x = x_list[i];
                left[(long long)x<<32|y] = x_list[i-1];
            }
        }

        unordered_map<long long,int>below;

        for(auto &[x,y_list]:x_map){
            sort(y_list.begin(),y_list.end());
            for(int i=1;i<y_list.size();++i){
                auto y = y_list[i];
                below[(long long)x<<32|y] = y_list[i-1];
            }
        }

        struct Query{
            int x1,x2,y1,y2;
            long long area;
        };

        vector<Query>queries;

        vector<int>xss;
        vector<int>yss;
        for(auto x:xCoord)xss.push_back(x);
        for(auto y:yCoord)yss.push_back(y);
        
        sort(xss.begin(),xss.end());
        sort(yss.begin(),yss.end());
        xss.erase(unique(xss.begin(),xss.end()),xss.end());
        yss.erase(unique(yss.begin(),yss.end()),yss.end());

        for(auto &[x2,y_list]:x_map){
            for(int i=1;i<y_list.size();++i){
                int y2 = y_list[i];
                auto it = left.find((long long)x2 << 32 | y2);
                if(it==left.end())continue;
                int x1 = it->second;
                int y1 = y_list[i-1];

                //x1 y2
                it = below.find((long long)x1 << 32 | y2);
                if(it==below.end()||it->second!=y1)continue;
                //x2 y1
                it = left.find((long long)x2 << 32 | y1);
                if(it==left.end()||it->second!=x1)continue;


                queries.emplace_back(
                  lower_bound(xss.begin(),xss.end(),x1)-xss.begin(),
                  lower_bound(xss.begin(),xss.end(),x2)-xss.begin(),
                  lower_bound(yss.begin(),yss.end(),y1)-yss.begin(),
                  lower_bound(yss.begin(),yss.end(),y2)-yss.begin(),
                  (long long)(x2-x1)*(y2-y1)
                );

            }
        }

        struct Data{
            int qid,sign,y1,y2;
        };

        vector<vector<Data>>qs(xss.size());
        

        for(int i=0;i<queries.size();++i){
            auto [x1,x2,y1,y2,_] = queries[i];
            if(x1>0)qs[x1-1].push_back({i,-1,y1,y2});
            qs[x2].push_back({i,1,y1,y2});
        }

        vector<int>res(qs.size());
        Fenwick tree(yss.size()+1);
        for(int i=0;i<xss.size();++i){
            for(int y:x_map[xss[i]]){
                tree.add(lower_bound(yss.begin(),yss.end(),y)-yss.begin()+1);
            }

            for(auto [qid,sign,y1,y2]:qs[i]){
                res[qid] += sign * tree.query(y1+1,y2+1);
            }
        }
        
        long long ans = -1;
        for(int i=0;i<res.size();++i){
            if(res[i] == 4)ans = max(ans,queries[i].area);
        }
        return ans;


    }
};