算法学习（十一）贪心算法

一、基本概念：

在寻找最优解时候，有很多常用的办法，比如说：贪心，分治，回溯，动态规划等等。这些思想有各自的优势，也相互联系，相互区别。 

贪心算法（又称贪婪算法）是指，在对问题求解时，总是做出在当前看来是最好的选择。 也就是说，不从整体最优上加以考虑，他所做出的是在某种意义上的局部最优解。

二、举例说明：

1.Leetcode 455 号问题： 分发饼干

题目描述

假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。对每个孩子 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

---

简单分析：

（1）每个小朋友拥有的胃口值是：g[i] / 每块饼干拥有的尺寸值是：j[i]

（2）每块饼干最多只能满足一个小朋友，如果尺寸不足就没办法满足胃口大的小朋友，也就是说胃口大的小朋友最难满足

（3）无论饼干尺寸是大是小，最多只能满足一个小朋友，如果把大饼干给胃口小的小朋友，那么胃口大的小朋友就更不可能被满足了，照此分析，我们先用最大的饼干去试试胃口比较大的小朋友能否满足，如果最大的饼干都不能满足他，那么我们只能对他说对不起，我们满足不了你。然后再满足胃口小点的小朋友，这样就可以让尽可能多的小朋友得到满足了。

这，就是贪心算法！

-----说完概念，该实践了-----代码如下：

package IMUHERO;

import java.util.Arrays;

public class cookies {
        public int findContentChildren(int[] g, int[] s) {
                Arrays.sort(g);//将胃口大的小朋友放后面
                Arrays.sort(s);//将尺寸大的饼干放后面
                int gi=g.length-1;
                int si=s.length-1;
                int result=0;
                while (gi>=0&&si>=0){
                        if (s[si]>=g[gi]){
                                result++;//胃口大的先满足
                                si--;//能满足才给
                        }
                        gi--;//最大的也不能满足，就直接不管了
                }
                return result;
        }

        public static void main(String[] args) {
                int []g={1,2,3};
                int []s={1,2,2,4};
                cookies c=new cookies();
                System.out.println(c.findContentChildren(g,s));
        }


        /// 455. Assign Cookies

/// 另一种解法：先尝试满足最不贪心的小朋友
/// 时间复杂度: O(nlogn)
/// 空间复杂度: O(1)
//                public int findContentChildren(int[] g, int[] s) {
//
//                        Arrays.sort(g);
//                        Arrays.sort(s);
//
//                        int gi = 0, si = 0;
//                        int res = 0;
//                        while(gi < g.length && si < s.length){
//                                if(s[si] >= g[gi]){
//                                        res ++;
//                                        gi ++;
//                                }
//                                si ++;
//                        }
//
//                        return res;
//                }
}

 ##########讲完贪吃的小朋友例题，相比你已经对贪心算法的概念：在对问题求解时，总是做出在当前看来是最好的选择。 也就是说，不从整体最优上加以考虑，他所做出的是在某种意义上的局部最优解，有了初步了解。

***************************************************************************************************************************

接下来我们再通过一道题目巩固贪心思想：

2.Leetcode 435号问题 无重叠区间

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

注意:

1. 可以认为区间的终点总是大于它的起点。
2. 区间 [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

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

---

分析1：动态规划（我们先尝试使用动态规划的思想来解决这道题目）

（1）两个区间不重叠的基本情况可以拆解成：后一个区间的头部和前一个区间的尾部重叠，或者更靠后，比如[0,1][1,2]，又比如说：[0,1][2,3]都是不重叠的情况。

（2）根据这个条件，我们可以分析出，要尽可能让两个区间靠近，才能留下尽可能多的区间（隐含条件就是，删除尽可能少的区间）

（3）为了达到这个目的，我们将二维数组先进行排序（按照我们定义的排序规则|详见代码|），这样可以确保每个区间头部小的靠前，相等是用尾部判断。

通过以上分析，我们可以写出如下代码：

package IMUHERO;

import java.util.Arrays;
import java.util.Comparator;
public class non_overlapping_interval {
    public int eraseOverlapIntervals(int[][] intervals) {
        int length=intervals.length;//0的情况就直接返回0！
        if (length==0)return 0;

        /*比较方法是：
         *头部不相等时比较头部，小的排前面。头部相等时比较尾部，尾部小的排前面
         *这样可以让区间尽量靠近，方便后续判断
         */
        Arrays.sort(intervals, new Comparator<int[]>(){
            public int compare(int [] arr1, int [] arr2){
                if(arr1[0] != arr2[0])
                    return arr1[0] - arr2[0];
                return arr1[1] - arr2[1];
            }
        });

        int [] memo = new int[length];//用于动态规划的记忆
        Arrays.fill(memo,1);            //初始的时候所有区间都只有个一个区间不重叠
        for (int i=1;i<length;i++){    //从1开始，因为下标0的区间不重叠数为1，上边已经声明
            for (int j=0;j<=i;j++){
                if (intervals[i][0]>=intervals[j][1]){    
                //判断后一个区间的头部是否>=前一个区间的尾部
                    memo[i]=Math.max(memo[i],memo[j]+1);
                }
            }
        }



        int res=0;
        for (int i=0;i<length;i++){
            res=Math.max(res,memo[i]);    //找到最大重叠数
        }
        return length-res;    //题目要求的是删除的个数
    }

}

分析2：贪心算法（我们再来尝试使用贪心算法的思想来解决这道题目）

（1）上面动态规划的解法给我们带来启发，下一个区间的头部一定要大于等于上一个区间的尾部才能不重叠，也就是说上一个区间的尾部直接决定了我们能从哪边进行对接。

（2）于是我们可以换一种排序方法，以尾部优先排序，尾部最先结束的区间排到前面去，就能保证尽可能早的接续。

（3）排序完后，我们遍历所有区间，如果尾部排在后面的区间，他的头部也比上一个还未接续的区间尾部大，那么这个区间就可接。

分析完贪心算法，我们就可以开始写出无比简介的代码啦：

package IMUHERO;

import java.util.Arrays;
import java.util.Comparator;

public class non_overlapping_interval2 {
    public int eraseOverlapIntervals(int[][] intervals) {
        int length=intervals.length;
        if (length==0)return 0;

        Arrays.sort(intervals, new Comparator<int[]>(){
            public int compare(int [] arr1, int [] arr2){
                if(arr1[1] != arr2[1])
                    return arr1[1] - arr2[1];    //尾部优先
                return arr1[0] - arr2[0];    //尾部相等时，再排头部
            }
        });
        int res=1;int j=0;  //j用于判断上一个不能被接续的区间
        for (int i=1;i<length;i++){
            if (intervals[i][0]>=intervals[j][0]){
                j=i;    //如果这个区间被i接续了，那么j标记就变成i,等待下次接续
                res++;  //结果
            }
        }

        return length-res;    //最终返回的是删除掉的区间数
    }
}

三、难点和困难

其实贪心算法最难的不是设计和编码，而是在于分析和判断这个问题能否用贪心算法来解决，如果判断错误很可能掉进坑里。

因此可以通过举反例来推翻自己的假设，也可以用数学归纳法和反证法来判断，当然最重要的还是勤加练习，争取练就一双一看就明的火眼金睛，加油！(#^.^#)