算法总结+力扣hot100|贪心算法

二刷：摆动序列，不要求连续子序列---不需要丢弃前面，而是在for循环中判断，当前元素是否满足条件，不满足就丢弃

最大子序和要求连续子序列---更换起始点，丢弃前面所有

最大子序列：

摆动序列：

1.455.分发饼干

遍历比较 饼干和胃口 大小

2 376. 摆动序列

不要求连续的子序列

遍历找前后两个差值

别用乘积--初始化为0，不能初始化为正或负

3.53. 最大子序和

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

将利润拆分，收集每天的正利润

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

 力扣hot：121. 买卖股票的最佳时机

5分钟写出来了，且没有错

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

5.55. 跳跃游戏

这道题目关键点在于：不用拘泥于每次究竟跳几步，而是看覆盖范围，覆盖范围内一定是可以跳过来的，不用管是怎么跳的。

6.45.跳跃游戏 II

贪心的思路，局部最优：当前可移动距离尽可能多走，如果还没到终点，步数再加一。整体最优：一步尽可能多走，从而达到最少步数。

class Solution {
    public int jump(int[] nums) {
        if (nums == null || nums.length == 0 || nums.length == 1) {
            return 0;
        }
        int count = 0;
        int max = 0;
        int curMax = 0;//
        for (int i = 0; i <= max; i++) {
            max = Math.max(max, nums[i] + i);
            if (max >= nums.length-1) {
                count++;
                break;
            }
            // 走到当前覆盖的最大区域时，更新下一步可达的最大区域
            if (i == curMax) {
                curMax=max;
                count++;
            }

        }
        return count;
    }
}

7.1005.K次取反后最大化的数组和

Arrays.sort(newNums, (a,b)->Math.abs(b)-Math.abs(a));

8.加油站 

class Solution {
    public int canCompleteCircuit(int[] gas, int[] cost) {
        int cur=0;
        int total=0;
        int index=0;//返回结果
        for (int i = 0; i < cost.length; i++) {
            cur+=gas[i]-cost[i];
            total+=gas[i]-cost[i];
            if (cur<0) {
                cur=0;
                index=(i+1)%cost.length;
            }
        }
        if (total<0) {
            return -1;}
        return index;
    }
}

9.135. 分发糖果

10.860.柠檬水找零

只有 5，10 ， 20

11.406.根据身高重建队列

先按身高排序：

再按第二个维度排序：

先再在列表que里插入：0号位置（7，0），1号位置（7，1）

再在1号位置插入（6，1）

此时：（7，1）变成在2号位置。

12.452. 用最少数量的箭引爆气球

局部最优：当气球出现重叠，一起射，所用弓箭最少。全局最优：把所有气球射爆所用弓箭最少。

为了让气球尽可能的重叠，需要对数组进行排序。

如果气球重叠了，重叠气球中右边边界的最小值 之前的区间一定需要一个弓箭。

class Solution {
    public int findMinArrowShots(int[][] points) {
        if (points.length==0) return 0;
        Arrays.sort(points,(a,b)->a[0]-b[0]);
        int count =1; int right =points[0][1];
        for (int[] is : points) {
            if (is[0]>right) {
                count++; right=is[1];
            }else{
                right=Math.min(right, is[1]);
            }
        }
        return count;
    }
}

13.435. 无重叠区间

1

14.763.划分字母区间

在遍历的过程中相当于是要找每一个字母的边界，如果找到之前遍历过的所有字母的最远边界，说明这个边界就是分割点了。此时前面出现过所有字母，最远也就到这个边界了。

有点类似  跳跃游戏  

循环每个字符，当i==index时（index就是其最后出现的边界）

上图中，a最后出现是8,在前8里遍历，如果有边界比8还大的，更新index，直达i==index时，此时可以划分。

class Solution {
    public List<Integer> partitionLabels(String s) {
        int[] last = new int[26];
        // 记录每个字符的最大index
        for (int i = 0; i < s.length(); i++) last[s.charAt(i) - 'a'] = i;

        int index=0; int start=-1;
        ArrayList<Integer> list=new ArrayList<>();
        for (int i = 0; i < s.length(); i++) {
            index=Math.max(index, last[s.charAt(i) - 'a']);
            if (i==index) {
                list.add(index-start);
                start=i; //保存上一次范围边界
            }
        }
        return list;
    }
}

15.56. 合并区间

class Solution {
    public int[][] merge(int[][] intervals) {
       if(intervals.length==0)return new int[0][2];
      //按区间开口进行升序
      Arrays.sort(intervals,(a,b)->a[0]-b[0]);
      //窗口合并
     ArrayList<int[]> merged= new ArrayList<int[]>();
     for(int i=0;i<intervals.length;i++){
        int L=intervals[i][0];
        int R=intervals[i][1];
        if(merged.size()==0||merged.get(merged.size()-1)[1]<L){
            merged.add(new int[]{L,R});
        }else{
            merged.get(merged.size()-1)[1]=Math.max(merged.get(merged.size()-1)[1],R);
        }
     }
     return merged.toArray(new int[merged.size()][]);
    }
}

16.738.单调递增的数字

将整数转为数组：个十百千

String s = String.valueOf(n);
char[] chars = s.toCharArray();

数组转字符串：

String.valueOf(chars)

字符串转整数：

String str = "123";
Integer num1 = new Integer(str);
int num2 = Integer.parseInt(str);
Integer num3 = Integer.valueOf(str);

return Integer.parseInt(String.valueOf(chars));

本题只要想清楚个例，例如98，一旦出现strNum[i - 1] > strNum[i]的情况（非单调递增），首先想让strNum[i - 1]减一，strNum[i]赋值9，这样这个整数就是89。就可以很自然想到对应的贪心解法了。

想到了贪心，还要考虑遍历顺序，只有从后向前遍历才能重复利用上次比较的结果。

最后代码实现的时候，也需要一些技巧，例如用一个flag来标记从哪里开始赋值9。