5.5 刷题

yysy头还晕，但是太久没学习了。坚持一下

最大子数组和

要注意ans初始化时初始化为-0x3f3f3f3f，因为数组中的值可能为负数，如果初始化为0就错了

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int n=nums.size();
        int res=0;
        int ans=-0x3f3f3f3f;
        for(int i=0;i<n;i++){
            if(nums[i]>res+nums[i]){
                //如果加上当前的值比从当前值开始要小，那么久重新开启子数组
                res=nums[i];
            }
            else{
                //如果不大那就要
                res+=nums[i];
            }
            ans=max(ans,res);
        }
        return ans;
    }
};

合并区间

服了，写的稀碎
要注意选择基准的末尾（当前右端最大）

class Solution {
public:
    static bool cmp(vector<int> a, vector<int> b){
        return a[0]<b[0];
    }

    vector<vector<int>> merge(vector<vector<int>>& intervals) {
        sort(intervals.begin(),intervals.end(),cmp);
        vector<vector<int>> ans;
        for(int i=0;i<intervals.size();i++){
            if(i+1<intervals.size()&&intervals[i][1]>=intervals[i+1][0]){
               int first=intervals[i][0],last=intervals[i][1];
               while(i+1<intervals.size()&&last>=intervals[i+1][0]){
                //合并
                    last=max(last,intervals[i+1][1]);
                    i++; 
                }  
                vector<int> res;
                res.push_back(first);
                res.push_back(last);
                ans.push_back(res);
            }
            else{
                //如果不能合并
                vector<int> res;
                res.push_back(intervals[i][0]);
                res.push_back(intervals[i][1]); 
                ans.push_back(res);              
            }
        }
        return ans;
    }
};

除自身以外数组的乘积

使用前缀和后缀积

class Solution {
public:
    vector<int> productExceptSelf(vector<int>& nums) {
        //利用前缀和后缀积
        vector<int> front;
        vector<int> behind;
        int n=nums.size();
        front.push_back(1);
        for(int i=0;i<n-1;i++){
            front.push_back(nums[i]*front[i]);
        }
        behind.push_back(1);
        reverse(nums.begin(),nums.end());
        for(int i=0;i<n-1;i++){
            behind.push_back(nums[i]*behind[i]);
        }
        reverse(behind.begin(),behind.end());
        vector<int> ans;
        for(int i=0;i<n;i++)
            ans.push_back(front[i]*behind[i]);
        return ans;
    }
};

优化空间复杂度方法

class Solution {
public:
    vector<int> productExceptSelf(vector<int>& nums) {
        vector <int> ans;
        int n=nums.size();
        ans.push_back(1);
        for(int i=0;i<n-1;i++)
            ans.push_back(nums[i]*ans[i]);
        int behind=1;
        for(int i=n-1;i>=0;i--){
            ans[i]*=behind;
            behind*=nums[i];
        }
        return ans;
    }
};

接雨水

按行求暴力

class Solution {
public:
    int trap(vector<int>& height) {
        
        //遍历每个高度的水柱
        int m=0;
        for(int i=0;i<height.size();i++){
            if(height[i]>m)
                m=height[i];
        }
        //得到最大值m，这也是需要遍历的水柱的行高
        int ans=0;
        int res=0;
        bool update=0;
        for(int i=1;i<=m;i++){
            update=0;
            res=0;
            for(int j=0;j<height.size();j++){
                if(height[j]>=i){
                    ans+=res;
                    res=0;
                    update=1; //当有高度比i高才开始更新
                }
                if(update&&height[j]<i){
                    res++;
                }
            }
        }
        return ans;
    }
};

按列求暴力

class Solution {
public:
    int trap(vector<int>& height) {
        //按照列遍历
        int ans=0;
        for(int i=0;i<height.size();i++){
            int max_l=0;
            int max_r=0;
            for(int l=0;l<i;l++){
                //找左面最高的
                if(height[l]>max_l)
                    max_l=height[l];
            }
            for(int r=i+1;r<height.size();r++){
                //找右面最高的
                if(height[r]>max_r)
                    max_r=height[r];
            }
            int final=min(max_l,max_r);
            if(final<=height[i]){
                //如果两边矮的小于当前的，那么就没有
                ;
            }
            else{
                ans+=(final-height[i]);
            }
        }
        return ans;
    }
};

提前记录左侧最大值和右侧最大值！！！

class Solution {
public:
    int trap(vector<int>& height) {
        //按照列遍历
        const int N=2*1e5+10;
        int ans=0;
        int max_left[N];
        int max_right[N];
        memset(max_left,0,sizeof max_left);
        memset(max_right,0,sizeof max_right);
        for(int i=1;i<height.size();i++){
            max_left[i]=max(max_left[i-1],height[i-1]);
        }
        for(int i=height.size()-2;i>=0;i--){
            max_right[i]=max(max_right[i+1],height[i+1]);
        }
        for(int i=0;i<height.size();i++){
            int final=min(max_left[i],max_right[i]);
            if(final<=height[i]){
                //如果两边矮的小于当前的，那么就没有
                ;
            }
            else{
                ans+=(final-height[i]);
            }
        }
        return ans;
    }
};