跳跃游戏

贪心解法
每次找到最远距离，然后最远距离的区间里面找下一次最远距离

class Solution {
public:
    int jump(vector<int>& nums) {
        int fur = 0;
        int len = nums.size();
        int step =0;
        int end = 0;
        for(int i =0;i < len-1 ; i++){
            if(fur >= i){
                //1.如果最远比下标+下标值远，则更新
                //2.如果当前下标走到上一次最远的地方,则step+1;
                fur = max(fur, i+nums[i]);
                if(i==end){
                    step = step+1;
                    end = fur;
                }
            }
        }
        return step;
    }
};

53.最大子序和

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int preSum = 0;
        int maxSum = nums[0];
        int len = nums.size();
        for(int i =0;i<len ; i++){
            preSum = max(preSum+nums[i],nums[i]);
            maxSum = max(preSum,maxSum);
        }
        return maxSum;
    }
};

1014.最大观光组合
score = value[i]+value[j]+i-j = (value[i]+i) + (value[j]-j)
先看value[i]+[i]再看value[j]-j : score[0] = value[0]+0 + max(1到len-1下标中value[j]-j的最大值)
先看value[j]-[j]再看value[i]+i : score[1] = value[1]-1 + max(0~1下标中value[i]+i的最大值)
两种方法中后者是可以用边遍历边维护的，因为计算最大值时下标是从小到大递增的。
dp[n] = max(values[j]-j+ max(values[i]+i),dp[n-1])

class Solution {
public:
    int maxScoreSightseeingPair(vector<int>& values) {
        int len = values.size() ;
        int a = values[0]+0;
        int maxScore = a;
       /* if(len==2){
            int t =max(values[0],values[1]);
            return max(t,values[0]+0+values[1]-1);
        }*/
        for(int j =1 ;j<=len-1;j++){
            int i=j-1;
            a = max(a, values[i]+i);
            maxScore = max(maxScore,a+values[j]-j);
        }
        return maxScore;
    }
};