力扣贪心算法

455. 分发饼干

1.要求

假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。对每个孩子 i ，都有一个胃口值 gi ，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干 j ，都有一个尺寸 sj 。如果 sj >= gi ，我们可以将这个饼干 j 分配给孩子 i ，这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子，并输出这个最大数值。

注意：

你可以假设胃口值为正。
一个小朋友最多只能拥有一块饼干。

示例 1:

输入: [1,2,3], [1,1]

输出: 1

解释:
你有三个孩子和两块小饼干，3个孩子的胃口值分别是：1,2,3。
虽然你有两块小饼干，由于他们的尺寸都是1，你只能让胃口值是1的孩子满足。
所以你应该输出1。
示例 2:

输入: [1,2], [1,2,3]

输出: 2

解释:
你有两个孩子和三块小饼干，2个孩子的胃口值分别是1,2。
你拥有的饼干数量和尺寸都足以让所有孩子满足。
所以你应该输出2.

2.思路

给一个孩子的饼干应当尽量小又能满足该孩子，这样大饼干就能拿来给满足度比较大的孩子。因为最小的孩子最容易得到满足，所以先满足最小的孩子.
本题因为，排列并不是有序的，因此需要排序。

class Solution {
    public int findContentChildren(int[] g, int[] s) {
        Arrays.sort(g);
        Arrays.sort(s);
        int gi=0;
        int si=0;
        while(gi<g.length && si<s.length){
            if(g[gi]<=s[si]){
                gi++;
            }
            si++;
        }
        return gi;
       
        
    }
}

435. 无重叠区间

1.要求

给定一个区间的集合，找到需要移除区间的最小数量，使剩余区间互不重叠。

注意:

可以认为区间的终点总是大于它的起点。
区间 [1,2] 和 [2,3] 的边界相互“接触”，但没有相互重叠。
示例 1:

输入: [ [1,2], [2,3], [3,4], [1,3] ]

输出: 1

解释: 移除 [1,3] 后，剩下的区间没有重叠。
示例 2:

输入: [ [1,2], [1,2], [1,2] ]

输出: 2

解释: 你需要移除两个 [1,2] 来使剩下的区间没有重叠。
示例 3:

输入: [ [1,2], [2,3] ]

输出: 0

解释: 你不需要移除任何区间，因为它们已经是无重叠的了。

2 思路

先计算最多能组成的不重叠区间个数，然后用区间总个数减去不重叠区间的个数。
在每次选择中，区间的结尾最为重要，选择的区间结尾越小，留给后面的区间的空间越大，那么后面能够选择的区间个数也就越大

class Solution {
    public int eraseOverlapIntervals(int[][] intervals) {
        if(intervals.length==0){
            return 0;
        }
        Arrays.sort(intervals,Comparator.comparingInt(o->o[1])); //对数组第二个元素排序
        int cnt=1;
        int end=intervals[0][1];
        for(int i=1;i<intervals.length;i++){
            if(intervals[i][0]<end){
                continue;
            }
            end=intervals[i][1];
            cnt++;
        }
       return intervals.length-cnt;
        
    }
}

//Arrays.sort(intervals, new Comparator() {
 //   @Override
   // public int compare(int[] o1, int[] o2) {
    //    return o1[1] - o2[1];
   // }
});

class Solution:
    def eraseOverlapIntervals(self, intervals: List[List[int]]) -> int:
        if(len(intervals)==0 or len(intervals)==1  ):
            return 0
        d=sorted(intervals,key=lambda x:x[1])
        cnt=1
        end=d[0][1]
        for [x,y] in d[1::]:
            if x<end:
                continue;
            end=y
            cnt+=1
        return len(intervals)-cnt;
            
        

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

1.要求

    在二维空间中有许多球形的气球。对于每个气球，提供的输入是水平方向上，气球直径的开始和结束坐标。由于它是水平的，所以y坐标并不重要，因此只要知道开始和结束的x坐标就足够了。开始坐标总是小于结束坐标。平面内最多存在104个气球。

一支弓箭可以沿着x轴从不同点完全垂直地射出。在坐标x处射出一支箭，若有一个气球的直径的开始和结束坐标为 xstart，xend， 且满足 xstart ≤ x ≤ xend，则该气球会被引爆。可以射出的弓箭的数量没有限制。 弓箭一旦被射出之后，可以无限地前进。我们想找到使得所有气球全部被引爆，所需的弓箭的最小数量。

Example:

输入:
[[10,16], [2,8], [1,6], [7,12]]

输出:
2

解释:
对于该样例，我们可以在x = 6（射爆[2,8],[1,6]两个气球）和 x = 11（射爆另外两个气球）。

2.思路

感觉和前一个题的差不多。都是排序后再对区间进行判断。如果区间大的在例外一个区间，就不计数，如果不在就计数。

class Solution {
    public int findMinArrowShots(int[][] points) {
        if (points.length==0){
            return 0;
        }
         Arrays.sort(points, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                return o1[1]-o2[1];
            }
        });
        int cnt=1;
        int end=points[0][1];
        for(int i=1;i<points.length;i++){
            if(end>=points[i][0]&&end<=points[i][1]){
                // end=points[i][1];
                continue;
            }
            cnt++;
            end=points[i][1];
            
        }
        return cnt;
        
        
    }
}

406. 根据身高重建队列

1要求

假设有打乱顺序的一群人站成一个队列。 每个人由一个整数对(h, k)表示，其中h是这个人的身高，k是排在这个人前面且身高大于或等于h的人数。 编写一个算法来重建这个队列。

注意：
总人数少于1100人。

示例

输入:
[[7,0], [4,4], [7,1], [5,0], [6,1], [5,2]]

输出:
[[5,0], [7,0], [5,2], [6,1], [4,4], [7,1]]

2.思路

贪心算法。将升高按照降序排列，将个数按照升序排列；

class Solution {
    public int[][] reconstructQueue(int[][] people) {
        if(people.length==0){
            return new int[0][0];
        }
        Arrays.sort(people, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                int t=o1[0]==o2[0]?o1[1]-o2[1]:o2[0]-o1[0];
                return t ;
            }
        });
        //高降序，个数升序；
         // Arrays.sort(people, (a, b) -> (a[0] == b[0] ? a[1] - b[1] : b[0] - a[0]));
        //插入对应位置
        List<int []> queue=new ArrayList<>();
        for(int [] p:people){
            queue.add(p[1],p);
        }
        return queue.toArray(new int[queue.size()][]);
        
        
    }
}

import functools
class Solution:
   
    def compare(self,a,b):
        if a[0]==b[0]:
            return a[1]-b[1]
        else:
            return b[0]-a[0]
    def reconstructQueue(self, people: List[List[int]]) -> List[List[int]]:
        """
        :type people: List[List[int]]
        :rtype: List[List[int]]
        """
#         t=sorted(people, key=functools.cmp_to_key(self.compare))
      
#         result=[]
#         for x in t:
#             result.insert(x[1],x)
        people.sort(key = lambda x: [-x[0], x[1]])
        res = []
        for p in people:
            res.insert(p[1], p)
        return res
        # return result

        
        

121. 买卖股票的最佳时机

1.要求

给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。

如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。

注意你不能在买入股票前卖出股票。

示例 1:

输入: [7,1,5,3,6,4]
输出: 5
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格。
示例 2:

输入: [7,6,4,3,1]
输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。

2.思路

1.暴力破解法，把所有的可能进行比较，找出最大的；

public class Solution {
    public int maxProfit(int prices[]) {
        int maxprofit = 0;
        for (int i = 0; i < prices.length - 1; i++) {
            for (int j = i + 1; j < prices.length; j++) {
                int profit = prices[j] - prices[i];
                if (profit > maxprofit)
                    maxprofit = profit;
            }
        }
        return maxprofit;
    }
}

2.动态规划 前i天的最大收益 = max{前i-1天的最大收益，第i天的价格-前i-1天中的最小价格}

class Solution {
    public int maxProfit(int[] prices) {
        
    int n = prices.length;
    // base case: dp[-1][0] = 0, dp[-1][1] = -infinity
    int dp_i_0 = 0, dp_i_1 = Integer.MIN_VALUE;
    for (int i = 0; i < n; i++) {
        // dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i])
        dp_i_0 = Math.max(dp_i_0, dp_i_1 + prices[i]);
        // dp[i][1] = max(dp[i-1][1], -prices[i])
        dp_i_1 = Math.max(dp_i_1, -prices[i]);
    }
    return dp_i_0;
 }

2.贪心算法；只要记录前面的最小价格，将这个最小价格作为买入价格，然后将当前的价格作为售出价格，查看当前收益是不是最大收益。

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

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

1.要求

给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。

注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

示例 1:

输入: [7,1,5,3,6,4]
输出: 7
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6-3 = 3 。
示例 2:

输入: [1,2,3,4,5]
输出: 4
解释: 在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。
因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。
示例 3:

输入: [7,6,4,3,1]
输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。

思路

贪心算法，只要后一个比前一个大就开始买卖；

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

605. 种花问题

1要求

假设你有一个很长的花坛，一部分地块种植了花，另一部分却没有。可是，花卉不能种植在相邻的地块上，它们会争夺水源，两者都会死去。

给定一个花坛（表示为一个数组包含0和1，其中0表示没种植花，1表示种植了花），和一个数 n 。能否在不打破种植规则的情况下种入 n 朵花？能则返回True，不能则返回False。

示例 1:

输入: flowerbed = [1,0,0,0,1], n = 1
输出: True
示例 2:

输入: flowerbed = [1,0,0,0,1], n = 2
输出: False
注意:

数组内已种好的花不会违反种植规则。
输入的数组长度范围为 [1, 20000]。
n 是非负整数，且不会超过输入数组的大小。

class Solution {
    public boolean canPlaceFlowers(int[] flowerbed, int n) {
        int l=flowerbed.length;
        int cnt=0;
        for(int i=0;i<l && cnt<l;i++){
            if(flowerbed[i]==1){
                continue;
            }
            int pre= i==0? 0: flowerbed[i-1];
            int next= i==l-1? 0: flowerbed[i+1];
            if(pre==0 && next==0){
                cnt++;
                flowerbed[i]=1;
            }
            
        }
        return cnt>=n;
      
    }
}

链接：https://leetcode-cn.com/problems/assign-cookies
https://github.com/CyC2018/CS-Notes/blob/master/notes/Leetcode%20%E9%A2%98%E8%A7%A3%20-%20%E8%B4%AA%E5%BF%83%E6%80%9D%E6%83%B3.md