leetcode双周赛 45

A:水题，求数组中只出现一次的元素的和。

class Solution {
public:
    int sumOfUnique(vector<int>& nums) {
        unordered_map<int,int> m;
        for(auto x:nums){
            m[x]++;
        }
        int res=0;
        for(auto x:m){
            if(x.second==1){
                res+=x.first;
            }
        }
        return res;
    }
};

B:找出子数组和的绝对值的最大值。

解法一：应用求最大子数组的双指针模型。

最终的答案要么是正数（非常大），要么是负数（非常小），应用两遍求最大子数组的双指针模型就可以求出答案。

class Solution {
public:
    int maxAbsoluteSum(vector<int>& nums) {
        int n=nums.size();
        int l=0,r=0;
        int sum=0,res=0;
        while(r<n){
            sum+=nums[r];
            r++;
            while(sum<0){
                sum-=nums[l];
                l++;
            }
            res=max(res,sum);
        }
        l=0,r=0;
        sum=0;
        while(r<n){
            sum+=nums[r];
            r++;
            while(sum>0){
                sum-=nums[l];
                l++;
            }
            res=max(res,-sum);
        }
        
        return res;
    }
};

解法二：利用前缀和

如果将原数组前缀和之后的话，就只需要枚举左右端点，但是时间上还是过不去。

然后发现如果此时我们求子数组最大值，那么对于每一个右端点i，我们需要知道的是1~i-1中的最小值。

如果求子数组的最小值，那么对于每一个右端点i，我们需要知道的是1~i-1中的最大值。

所以在前缀后之后，维护max_val，min_val就可以了。

class Solution {
public:
    int maxAbsoluteSum(vector<int>& nums) {
        int n=nums.size();
        vector<int> s(n+1);
        for(int i=1;i<=n;i++){
            s[i]=s[i-1]+nums[i-1];
        }
        int max_val=0,min_val=0;//初始化为0是因为要求的是abs，所以不能初始化为无穷
                                //而初始化为0正好满足选择空数组的情况
        int res=0;//初始状态就是选择空数组
        for(int i=1;i<=n;i++){
            res=max(res,abs(s[i]-max_val));
            res=max(res,abs(s[i]-min_val));
            max_val=max(max_val,s[i]);
            min_val=min(min_val,s[i]);
        }
        return res;
    }
};

C:给定一个字符串，若左端点==右端点，那么可以将左边和右边大于一个的字符删除。求删除后的最短长度。

证明：如果删的话，一定尽可能地全部删掉。

　　　　假设两边都不删完，那么下一次还是得删，所以不如删完。

　　　　假设其中一边不删完，不妨设是左边，那么删完之后的字符串必定左端点不等于右端点，不如删完。

所以每次如果左端点等于右端点的话，直接删完就好了。

考试的时候的代码：

class Solution {
public:
    int minimumLength(string s) {
        int begin=0,end=s.size()-1;
        while(s[begin]==s[end]&&begin<end){
            int l=begin,r=end;
            while(l<=end&&s[l]==s[begin]) l++;
            while(r>=begin&&s[r]==s[end]) r--;
            if(l>r) return 0;
            begin=l,end=r;
        }
        return end-begin+1;
    }
};

更简洁的代码：

class Solution {
public:
    int minimumLength(string s) {
        int i=0,j=s.size()-1;
        while(i<j){
            if(s[i]!=s[j]) break;
            char c=s[i];
            while(i<=j&&s[i]==c) i++;
            while(i<=j&&s[j]==c) j--;
        }
        return j-i+1;
    }
};

D:给定n个区间，每个区间有一个价值，选择k个不相交的价值最大的区间，返回最大价值。

 因为计算f [ i ] [ j ]的时候，需要找到右端点小于i左端点的最右边的那个区间。

所以我们可以将区间按照右端点排序，然后利用二分来寻找该区间。

这样的话时间复杂度为n*k*log n 

const int N=1e6+10;
struct Q{
    int s,e,v;
    bool operator<(const Q& t){
        return e<t.e;
    }
}q[N];
class Solution {
public:
    int maxValue(vector<vector<int>>& events, int k) {
        int n=events.size();
        vector<vector<int>> f(n+1,vector<int>(k+1));
        for(int i=1;i<=n;i++){
            q[i]={events[i-1][0],events[i-1][1],events[i-1][2]};
        }
        sort(q+1,q+1+n);
        for(int i=1;i<=n;i++){
            for(int j=1;j<=k;j++){
                f[i][j]=f[i-1][j];//不选第i个
                int l=0,r=i-1;
                while(l<r){
                    int mid=l+r+1>>1;
                    if(q[mid].e<q[i].s) l=mid;
                    else r=mid-1;
                }
                f[i][j]=max(f[i][j] , f[r][j-1]+q[i].v);
            }
        }
        return f[n][k];
    }
};