求最大利润 将每天的正利润加和

    public int maxProfit(int[] prices) {
        int totalPrices = 0;
        for(int i=0;i<prices.length;i++){
            if(i<prices.length-1&&prices[i+1]>prices[i]){
                totalPrices += prices[i+1]-prices[i];
            }
        }
        return totalPrices;
    }

问题就转化为跳跃覆盖范围究竟可不可以覆盖到终点

每移动一个单位，就更新最大覆盖范围。

贪心算法局部最优解：每次取最大跳跃步数（取最大覆盖范围），整体最优解：最后得到整体最大覆盖范围，看是否能到终点。

    public boolean canJump(int[] nums) {
//        遍历当前值范围的数 并且在范围之内加上当前值的范围 能够到达数组的长度 即能跳到终点
        int cover = 0;
//        更新cover范围 并且在此范围遍历
        for (int i = 0; i <= cover; i++) {
            cover = Math.max(i + nums[i], cover);
            if (cover >= nums.length - 1) {
                return true;
            }
        }
        return false;
    }

    public int jump(int[] nums) {
        int next = 0;
        int count = 0;
        int cur =0;
//      在数的范围内找到覆盖范围最大的数 当遍历到范围的最后一个值 count++ 直到cur 遍历到数组末尾
        for(int i=0;i<nums.length;i++){
//           1. 在数的范围内找到覆盖范围最大的数  //在可覆盖区域内更新最大的覆盖区域
            next = Math.max(next, i+nums[i]);
//           2. 当遍历到范围的最后一个值 count++
            if(i == cur){
                if(cur !=nums.length-1){
                    count++;
                    cur =next;
                    if(cur >= nums.length-1){
                        break;
                    }
                }else {
                    break;
                }
            }
        }
        return count;
    }

贪心思想 ： 存在负数取反 选择绝对值最大的取反 同理都大于0 选择最小的正数取反 从而局部最优到整体最优

    public int largestSumAfterKNegations(int[] nums, int k) {
        int count = 0;
        Arrays.sort(nums);
        for(int i = 0;i<nums.length;i++){
            if(k>0&&nums[i]<0){
                nums[i] = -nums[i];
                k--;
            }
        }
//        将负数转为正数的数组 重新排序
        Arrays.sort(nums);
        if(k%2==1){
            nums[0] = -nums[0];
        }
        for (Integer i : nums){
            count =count+i;
        }
        return count;
    }