代码随想录第32天

1.买卖股票的最佳时机II：

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int result = 0;
        for (int i = 1; i < prices.size(); i++) {
            result += max(prices[i] - prices[i - 1], 0);
        }
        return result;
    }
};

局部最优：收集每天的正利润，全局最优：求得最大利润。

诶嘿，自己想出来了。

2.跳跃游戏：

class Solution {
public:
    bool canJump(vector<int>& nums) {
        int cover = 0;
        if (nums.size() == 1) return true; // 只有一个元素，就是能达到
        for (int i = 0; i <= cover; i++) { // 注意这里是小于等于cover
            cover = max(i + nums[i], cover);
            if (cover >= nums.size() - 1) return true; // 说明可以覆盖到终点了
        }
        return false;
    }
};

class Solution {

public:

    bool canJump(vector<int>& nums) {

        if(nums.size()==1&&nums[0]==0) return true;

        for(int i=0;i<nums.size();i++){

            if(nums[i]==0&&i!=nums.size()-1){

                int f=0;

                for(int j=0;j<i;j++){

                    if(nums[j]+j>i){

                        f=1;

                        break;

                    }

                }

                if(f==0){

                    return false;

                }

            }

        }

        return true;

    }

};

 他的思路比我的简单，他是求覆盖范围只要能到结尾就输出true，而我的是求数为0且不是最后一位时的情况，求0前面的数能不能跳过他，不能就输出true，能就找下一个0，如果都可以就输出true，这道题没有0的情况是肯定是true的，

3.跳跃游戏||：

方法1：

class Solution {
public:
    int jump(vector<int>& nums) {
        if (nums.size() == 1) return 0;
        int curDistance = 0;    // 当前覆盖最远距离下标
        int ans = 0;            // 记录走的最大步数
        int nextDistance = 0;   // 下一步覆盖最远距离下标
        for (int i = 0; i < nums.size(); i++) {
            nextDistance = max(nums[i] + i, nextDistance);  // 更新下一步覆盖最远距离下标
            if (i == curDistance) {                         // 遇到当前覆盖最远距离下标
                if (curDistance < nums.size() - 1) {       // 如果当前覆盖最远距离下标不是终点
                    ans++;                                  // 需要走下一步
                    curDistance = nextDistance;             // 更新当前覆盖最远距离下标（相当于加油了）
                    if (nextDistance >= nums.size() - 1) break; // 下一步的覆盖范围已经可以达到终点，结束循环
                } else break;                               // 当前覆盖最远距到达集合终点，不用做ans++操作了，直接结束
            }
        }
        return ans;
    }
};

首先贪心思路：

局部最优：当前可移动距离尽可能多走，如果还没到终点，步数再加一。整体最优：一步尽可能多走，从而达到最小步数。（当然这个思路看看就好）

这里还是有个特殊情况需要考虑，当移动下标达到了当前覆盖的最远距离下标时

• 如果当前覆盖最远距离下标不是是集合终点，步数就加一，还需要继续走。
• 如果当前覆盖最远距离下标就是是集合终点，步数不用加一，因为不能再往后走了。

curDistance是当前覆盖最远距离的下标，nextDistance是遍历当前最远距离时能覆盖的最远距离的的下标，注意都是下标！如果curDistance小于数组的最后一位代表这一步怎么都跳不到结尾，所以要在加一步。

注：

1.

if (i == curDistance) {                         // 遇到当前覆盖最远距离下标
                if (curDistance < nums.size() - 1) {       // 如果当前覆盖最远距离下标不是终点
                    ans++;                                  // 需要走下一步
                    curDistance = nextDistance;             // 更新当前覆盖最远距离下标（相当于加油了）
                    if (nextDistance >= nums.size() - 1) break; // 下一步的覆盖范围已经可以达到终点，结束循环
                } else break;                               // 当前覆盖最远距到达集合终点，不用做ans++操作了，直接结束
            }

判断是有重复的。 

            if (i == curDistance) {                         

                if (curDistance < nums.size() - 1) {       

                    ans++;                                 

                    curDistance = nextDistance;             

                } else break;                               

            }

或者这样：
 

if (i == curDistance) {                        

                    ans++;                                  

                    curDistance = nextDistance;            

                    if (nextDistance >= nums.size() - 1) break; 

            }

都可以，都是对curDistance的判断

方法2：

相对于方法1的区别是只要i遍历到curDistance时就ans加1，不管curDistance是不是集合结尾

想要达成这样的效果只要让移动下标，最大只能移动到nums.size - 2的地方就可以了。因为这样curDistance就永远不会是集合结尾了，也就不用分类讨论了。

但是题目要求是要到集合结尾，所以代码要相对改一下：

第一肯定是只遍历到nums.size - 2。

第二是不用讨论curDistance是不是集合结尾，只要i遍历到curDistance时ans就加1

然后是关于遍历到nums.size - 2是否就代表就是答案，说白了这个代码能不能代表遍历到nums.size - 2的两种情况（和方法1时的特殊情况类似）：

1.

 

 

然后发现可以

// 版本二
class Solution {
public:
    int jump(vector<int>& nums) {
        int curDistance = 0;    // 当前覆盖的最远距离下标
        int ans = 0;            // 记录走的最大步数
        int nextDistance = 0;   // 下一步覆盖的最远距离下标
        for (int i = 0; i < nums.size() - 1; i++) { // 注意这里是小于nums.size() - 1，这是关键所在
            nextDistance = max(nums[i] + i, nextDistance); // 更新下一步覆盖的最远距离下标
            if (i == curDistance) {                 // 遇到当前覆盖的最远距离下标
                curDistance = nextDistance;         // 更新当前覆盖的最远距离下标
                ans++;
            }
        }
        return ans;
    }
};

 

理解本题的关键在于：以最小的步数增加最大的覆盖范围，直到覆盖范围覆盖了终点，这个范围内最小步数一定可以跳到，不用管具体是怎么跳的，不纠结于一步究竟跳一个单位还是两个单位。