代码随想录算法训练营三十四~三十六天|贪心

三十四天

柠檬水找零

public class Solution {
    public bool LemonadeChange(int[] bills) {
        int five = 0,ten = 0,twe = 0;
        for(int i=0;i= 1 && five >= 1){
                    ten -= 1;
                    five -= 1;
                }
                else if(five >= 3){
                    five -= 3;
                }
                else{return false;}
            }
        }
        if(five>=0 && ten>=0 && twe>=0){return true;}
        return false;
    }
}

根据身高重建队列

406. 根据身高重建队列 - 力扣（LeetCode）

要点：和分发糖果那题一个思路，两边不要同时考虑，先从高往低排列身高h，再根据每个数组的k值大小重新排列。

难点的地方在代码实现，具体看备注。

public class Solution {
    public int[][] ReconstructQueue(int[][] people) {
        //这段代码，是根据判断条件的对错去做降序排列。
        //true就表示前面的大，false表示后面的小
        Array.Sort(people,new Comparison((a,b) =>{
            //如果a[0] == b[0]，指h是否相同，相同返回k值的比较
            if(a[0] == b[0]) return a[1] - b[1];
            return b[0] - a[0];
        }));

        IList> queue = new List>();
        foreach(int[] person in people){
            //取K值
            int position = person[1];
            //根据position的值，对应下标插入。
            //例如先进{7，0}，再进{7，1}。此时queue是{{7，0}，{7，1}}
            //再加入{6，1}时，会按照k=1，在队列的下标1插入，此时queue是{{7，0}，{6，1}，{7，1}}
            queue.Insert(position,person.ToList());
        }
        //转换成二维数组
        return queue.Select(person => person.ToArray()).ToArray();
    }
}

用最少数量的箭引爆气球

452. 用最少数量的箭引爆气球 - 力扣（LeetCode）

要点：先排序，然后for循环，找气球2的起点和气球1的终点比较，比气球1小，箭数加1（因为此时不重叠）；否则，刷新气球2的终点（气球1和气球2的终点取最小，此时气球1和气球2的重叠部分成[2,6]，取6），

public class Solution {
    public int FindMinArrowShots(int[][] points) {
        if(points.Length == 0)return 0;
        Array.Sort(points,(a,b) =>{
            return a[0] - b[0];
        });

        int result = 1;
        for(int i=1;i points[i-1][1]){
                result++;
            }
            else{
                points[i][1] = Math.Min(points[i-1][1],points[i][1]);
            }
        }
        return result;
    }
}

三十五天

无重叠区间

要点：和引爆气球相同的思路，只要intervals[i][0]>=end（第二个区间的下标0比第一个区间的下标1大，说明不重叠），result++，最后结果数组长度减去result。

public class Solution {
    public int EraseOverlapIntervals(int[][] intervals) {
        if(intervals.Length == 1){return 0;}
        Array.Sort(intervals, Comparer.Create(
            (a, b) => a[1] == b[1] ? a[0] - b[0] : a[1] - b[1])
        );
        //记录非交叉区
        int result = 1;
        int end = intervals[0][1];
        for(int i=1;i= end){
                result++;
                end = intervals[i][1];
            }
        }
        return intervals.Length - result;
    }
}

划分字母区间

763. 划分字母区间 - 力扣（LeetCode）

要点：把整个字符串遍历，并且收集好每个字符最后出现的下标值，然后就是根据收集的hash去遍历字符串，遍历过程中只要i==字符最后出现的下标值，就记录到result。遍历完成输出result。

public class Solution {
    public IList PartitionLabels(string s) {
        int[] hash = new int[26];
        for(int i=0;i result = new List();
        for(int i=left;i

合并区间

56. 合并区间 - 力扣（LeetCode）

要点：主要思路和无重叠区间这题一样，也是通过数组的end去和start比较。合并的话就是更新数组的end就行。

public class Solution {
    public int[][] Merge(int[][] intervals) {
        IList result = new List();
        if(intervals.Length == 0){return result.ToArray();}

        Array.Sort(intervals,(a,b) =>a[0].CompareTo(b[0]));

        result.Add(intervals[0]);

        for(int i=0;i= intervals[i][0]){
                result[result.Count -1][1] = Math.Max(result[result.Count-1][1],intervals[i][1]);
            }
            else{
                result.Add(intervals[i]);
            }
        }
        return result.ToArray();
    }
}

三十六天

单调递增的数字

738. 单调递增的数字 - 力扣（LeetCode）

要点：题目是要获取小于等于n的值，此值要从左往右单调递增，并且是能获取到的最大值。先从后向前遍历，因为从前向后遍历可能会前面比后面的位大的情况（’32‘这种）。只要每次遍历到s[i-1] > s[i]，就要记录size（作为之后赋值9的开始下标位），同时i-1的值要减1。第一次遍历完后，二次遍历就是从size开始向后赋值9，最后输出。

public class Solution {
    public int MonotoneIncreasingDigits(int n) {
        string s = n.ToString();
        
        int size = s.Length;
        for(int i=s.Length-1;i>0;i--){
            if(s[i-1] > s[i]){
                size=i;
                //这里是拼接字符串，从（0，i-1），然后i-1对应的值减1，后面再拼接i之后的值。
                s = s.Substring(0,i-1)+(char)(s[i-1]-1)+s.Substring(i);
            }
        }
        for(int i=size;i