Leetcode--第 240 场周赛

第 240 场周赛

A 人口最多的年份

思路：运用差分思想，将出身年人数加1，死亡年人数减一，因为不包括死亡年人数所以要在死亡年人数减一，然后运用前缀和求最多人数的那一年

class Solution {
public:
    int maximumPopulation(vector<vector<int>>& logs) {
        int a[5000],s[5000];
        memset(a,0,sizeof a);
        memset(s,0,sizeof s);
        sort(logs.begin(),logs.end());
        int num=0,ans=0,op=logs[0][1]-1;
        
        for(int i=0;i<logs.size();i++){
            a[logs[i][0]]++;
            a[logs[i][1]]--;
        }
        for(int i=1950;i<=2050;i++)s[i]=a[i]+s[i-1];
        for(int i=1950;i<=2050;i++){
            if(num<s[i]){
                num=s[i];
                ans=i;
            }
        }
        return ans;
    }
};

B 下标对中的最大距离

思路：由于是数组是非递增数组，因此可以想到用二分来找到对于数组nums1里面再nums2对应值的下标（ Q_Q 刚开始二分写反了）

class Solution {
public:
    int maxDistance(vector<int>& nums1, vector<int>& nums2) {
        int a[100010];
        int num=0;
        for(int i=0;i<nums1.size();i++){
            int l=i,r=nums2.size()-1;
            while(r>l){
                int mid=(l+r+1)>>1;
                if(nums1[i]>nums2[mid])r=mid-1;
                else l=mid;
            }
            //cout<<i<<" "<<l<<" "<<r<<endl;
            num=max(num,r-i);
        }
        cout<<endl;
        return num;
    }
};

C 子数组最小乘积的最大值

思想：单调栈+前缀和
维护以当前值为最小值的区间，从当前位置找到左边第一个小于当前值的下标存下来，从当前位置在找到右边第一个小于当前值的下标存下来，在用前缀和求出后面可以找到的区间值，然后循环找对应区间的最大值

const int mod=1e9+7;
class Solution {
public:
    int maxSumMinProduct(vector<int>& nums) {
        int n=nums.size();
        nums.insert(nums.begin(),0);
        vector<int>l(n+10,0),r(n+10,n+1);
        vector<pair<int,int>>st;//单独栈
        //正序
        for(int i=1;i<=n;i++){
            //维护一个左边第一个比他小的
            while(st.size()&&st.back().first>=nums[i])st.pop_back();
            if(!st.size()){
                l[i]=0;
            }
            else l[i]=st.back().second;
            st.push_back({nums[i],i});
        }
    st.clear();
        //逆序
        for(int i=n;i>=1;i--){
            while(st.size()&&st.back().first>=nums[i])st.pop_back();
            if(!st.size()){
                r[i]=n+1;
            }
            else r[i]=st.back().second;
            st.push_back({nums[i],i});
        }
        long long res=0;
        vector<long long>s(n+10,0);
        for(int i=1;i<=n;i++)s[i]=s[i-1]+nums[i];
        for(int i=1;i<=n;i++){
            int left=l[i]+1,right=r[i]-1;
            long long t=1ll*nums[i]*(s[right]-s[left-1]);
            res=max(res,t);
        }
        return res%mod;
    }
};

D 有向图中最大颜色值

思路：拓扑图
记录每个点入度的个数，将入度为0的点存入数组中，然后宽搜一下，将其26个字母颜色和前面的进行跟新，自己这一程会在下一层跟新，在判断是否有环时，每个点如果都是其他点转换过来必定在宽搜时进行消去，最终度数为0，然后求一个最大的值

class Solution {
public:
    int largestPathValue(string colors, vector<vector<int>>& edges) {
        unordered_map<int,vector<int>> g;
        int n=colors.size();
        vector<int> d(n+10,0);
        for(auto e:edges)
        {
            int a=e[0],b=e[1];
            g[a].push_back(b);
            d[b]++;
        }
        queue<int> q;
        for(int i=0;i<n;i++) if(d[i]==0) q.push(i);
        vector<vector<int>> f(n+10,vector<int>(30,0));

        while(q.size())
        {
            auto t=q.front();
            q.pop();
            f[t][colors[t]-'a']++;
            for(auto x:g[t])
            {
                for(int i=0;i<26;i++) f[x][i]=max(f[x][i],f[t][i]);
                if(--d[x]==0)
                {
                    q.push(x);
                }
            }
        }
        for(int i=0;i<n;i++) if(d[i]) return -1;
        int res=0;
        for(int i=0;i<n;i++) for(int j=0;j<26;j++) res=max(res,f[i][j]);
        return res;
    }
};