dp之最大子序和、爬楼梯及二分插入

总结

第一题考了dp、贪心；第二题考了二分查找；第三题考了dp；dp确实麻烦，接下来几天都做做这类的题目

题目I

题解

	// 暴力解法，很悲催的是果然超出时间限制了
	int maxSubArray(vector<int>& nums) {
        vector<int> temp;
        for(int i=1;i<=nums.size();i++){
            for(int j=0;j+i<=nums.size();j++){
                int t=0;
                for(int k=j;k<=j+i-1;k++){
                    t+=nums[k];
                }
                temp.push_back(t);
            }
        }
        return *max_element(temp.begin(),temp.end());
    }

	// 动态规划，遍历的方式和之前的不同
	int maxSubArray(vector<int>& nums) {
        vector<int> dp;
        dp.push_back(nums[0]);
        for(int i=1;i<nums.size();i++){
            if(dp[i-1]+nums[i]>nums[i]){
                dp.push_back(dp[i-1]+nums[i]);
            }
            else{
                dp.push_back(nums[i]);
            }
        }
        return *max_element(dp.begin(),dp.end());
    }

	// 贪心算法
	// 需要注意的是，result和sum的初始值不是nums[0]
	int maxSubArray(vector<int>& nums) {
        int result=INT_MIN;
        int sum=0;
        for(int i=0;i<nums.size();i++){
            sum+=nums[i];
            if(sum>result){
                result=sum;
            }
            if(sum<0){
                sum=0;
            }
        }
        return result;
    }

感悟

leetcode上的深度解析
动态规划：选取每个节点作为子串终节点时的最大值
贪心算法：在从左到右遍历的时候，每次都让结果尽可能大，当sum小于0时就重新选取字串，但result不变；result只在sum大于result时变为result

题目II

题解

	int searchInsert(vector<int>& nums, int target) {
        int ans=nums.size();
        int left=0;
        int right=ans-1;
        while(left<=right){
            int mid=(right-left)/2+left;
            if(nums[mid]>=target){
                ans=mid;
                right=mid-1;
            }
            else{
                left=mid+1;
            }
        }
        return ans;
    }

感悟

二分查找的边界真的很麻烦呀，就把这个当作模板背下来好了

题目III

题解

	int climbStairs(int n) {
        vector<int> vc(n+2,0);
        vc[1]=1;
        vc[2]=2;
        for(int i=3;i<=n;i++){
            vc[i]=vc[i-1]+vc[i-2];
        }
        return vc[n];
    }

感悟

典型的动态规划题，可以转化为斐波那契数列，具体参考
dp算法解析