Day 30 算法记录|贪心算法（2）

Leecode

122. 买卖股票的最佳时机 II

贪心算法解析：
把利润分解为每天为单位的维度,第 0 天买入，第 3 天卖出:
相当于(prices[3] - prices[2]) + (prices[2] - prices[1]) + (prices[1] - prices[0])。

因为可以多次购买，所以就只在有上涨的时段购买和抛售，累加起就是我的收益
局部最优：收集每天的正利润，全局最优：求得最大利润。

class Solution {
    public int maxProfit(int[] prices) {
      int res = 0;
      for(int i=1;i<prices.length;i++){
          res += Math.max(prices[i]-prices[i-1],0);
      }
      return res;
    }
}

动态规化：

class Solution {
    public int maxProfit(int[] prices) {
      int length = prices.length;
      int[] hold = new int[ length+1 ]; //hold[i]表示第i天结束，持有股票最大的收益
      int[] sold = new int[ length+1];//是old[i]表示第i天结束，卖出股票最大的收益
      hold[0] = Integer.MIN_VALUE;
      for(int i=1;i<=length;i++){
        int p = prices[i-1];
       hold[i] = Math.max(hold[i-1],sold[i-1]-p); //卖出去再买一张新的 or 一直持有之前的
       sold[i] = Math.max(sold[i-1],hold[i-1]+p); //今天卖出之前的股票 or 一直不买入
      }
 return sold[length];
}
}

边界问题，考虑第一天结束后，hold[1] = -p; sold[1] = sold[0]， 所以就需要hold[0] = Integer.MIN_VALUE

55. 跳跃游戏

贪心算法
这道题的漏洞就是一定要避开0
如果存在0，jump[i] = 0+i;
当index调到当前节点i，此时max = i, 就会永远不动了，返回false

class Solution {
    public boolean canJump(int[] nums) {
     int length = nums.length;
        int [] jump = new int[length]; // jump[i]表示处于i时，能跳到的 最远位置

    for(int i=0;i<length;i++){
       jump[i] = nums[i]+i;
    }
    int index =0;
    int max = jump[0];

    while(index<length && index<= max){
      max = max>jump[index]?max:jump[index];
      index++;
    }
    if(index == length){
        return true;
    }
   return false;
    }
}

简化版

class Solution {
    public boolean canJump(int[] nums) {
     int length = nums.length;
       
    int index =0;
    int max = nums[0];

    while(index<length && index<= max){
      max = max>(nums[index]+index)?max:(nums[index]+index);
      index++;
    }
    if(index == length){
        return true;
    }
   return false;
    }

代码随想录的解析
每次取最大的跳跃步数，这个就是可以跳跃的覆盖范围。
转化为跳跃覆盖范围究竟可不可以覆盖到终点！
一步贪心
贪心算法局部最优解：每次取最大跳跃步数（取最大覆盖范围），整体最优解：最后得到整体最大覆盖范围，看是否能到终点

class Solution {
    public boolean canJump(int[] nums) {
        if (nums.length == 1) {
            return true;
        }
        //覆盖范围, 初始覆盖范围应该是0，因为下面的迭代是从下标0开始的
        int coverRange = 0;
        //在覆盖范围内更新最大的覆盖范围
        for (int i = 0; i <= coverRange; i++) {
            coverRange = Math.max(coverRange, i + nums[i]);
            if (coverRange >= nums.length - 1) {
                return true;
            }
        }
        return false;
    }
}

45.跳跃游戏 II

讲的很详细
i<length-1
如果若curmax == length-1，不能执行count++
所以如果只计算到倒数第二步，如果curmax也恰好框到这里，就直接加1

class Solution {
    public int jump(int[] nums) {
    int count =0;
    int curmax =0;
    int nextmax = 0;

   for(int i=0;i<nums.length-1;i++){  // 
       nextmax = Math.max(i+nums[i],nextmax); //记录第一个框里面最远的，作为下一个框
       if( i == curmax) { //走到当前框最远的地方，更新max
           count++;
           curmax = nextmax;
       }
   }
    return count;
    }
}