【贪心基本算法】贪心算法常见题目

活动安排问题（贪心算法）求解

问题描述：

设有n个活动的集合E={1,2,…,n}，其中每个活动都要求使用同一资源，如演讲会场等，而在同一时间内只有一个活动能使用这一资源。
每个活动i都有一个要求使用该资源的起始时间si和一个结束时间fi，且si < fi。
如果选择了活动i，则它在半开时间区间[si, fi)内占用资源。若区间[si, fi)与区间[sj, fj)不相交，则称活动i与活动j是相容的。
也就是说，当si≥fj或sj≥fi时，活动i与活动j相容。活动安排问题就是要在所给的活动集合中选出最大的相容活动子集合。

求解思路：

将活动按照结束时间进行从小到大排序。然后用i代表第i个活动，s[i]代表第i个活动开始时间，f[i]代表第i个活动的结束时间。按照从小到大排序，挑选出结束时间尽量早的活动，并且满足后一个活动的起始时间晚于前一个活动的结束时间，全部找出这些活动就是最大的相容活动子集合。事实上系统一次检查活动i是否与当前已选择的所有活动相容。若相容活动i加入已选择活动的集合中，否则，不选择活动i，而继续下一活动与集合A中活动的相容性。若活动i与之相容，则i成为最近加入集合A的活动，并取代活动j的位置。

下面给出求解活动安排问题的贪心算法，各活动的起始时间和结束时间存储于数组s和f中，且按结束时间的非减序排列。

下面给出求解活动安排问题的贪心算法，各活动的起始时间和结束时间存储于数组s和f中，且按结束时间的非减序排列。

算法设计如下：

public static int greedySelector(int[] s, int[] f, boolean[] a) {

        int n = s.length - 1;
        a[1] = true;
        int j = 1;
        int count = 1;
        for (int i = 2; i <= n; i++) {
            if (s[i] >= f[j]) {
                a[i] = true;
                j = i;
                count++;
            } else {
                a[i] = false;
            }

        }
        return count;

    }

贪心算法greedySelector一开始选择活动1，并将j初始化为1。然后依次检查活动i是否与当前已经选择的所有活动相容。
若相容则将活动i加入已经选择活动的集合A中；否则，不选择活动i，而继续检查下一活动与集合A中活动的相容性。
由于fj总是当前集合A中所有活动的最大结束时间，故活动i与当前集合A中所有活动相容的充分且必要的条件是其开始时间si不早于最近加入集合A的活动j的结束时间fj，即 si>=fj。
若活动i与之相容，则i成为最近加入集合A中的活动，并取代活动j的位置。由于输入的活动以其完成时间的非减序排列，所以算法greedySelector每次总是选择具有最早完成时间的相容活动加入集合A中。

直观上，按这种方法选择相容活动为未安排活动留下尽可能多的时间。也就是说，该算法的贪心选择的意义是剩余的可安排时间段极大化，以便安排尽可能多的相容活动。

算法greedySelector的效率极高。当输入的活动已经按结束时间的非减序排列，算法只需O（n）的时间安排n个活动，使最多的活动能相容地使用公共资源。

完整代码如下：

package com.bean.algorithmbasic;

public class ActivitiesDemo {

    public static int greedySelector(int[] s, int[] f, boolean[] a) {

        int n = s.length - 1;
        a[1] = true;
        int j = 1;
        int count = 1;
        for (int i = 2; i <= n; i++) {
            if (s[i] >= f[j]) {
                a[i] = true;
                j = i;
                count++;
            } else {
                a[i] = false;
            }
        }
        return count;

    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] s = { 1, 3, 0, 5, 3, 5, 6, 8, 8, 2, 12 };
        int[] f = { 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14 };
        boolean[] a = new boolean[s.length];

        int result = greedySelector(s, f, a);
        System.out.println("Result is: " + result);
        for (int i = 1; i <= s.length - 1; i++) {
            if (a[i]) {
                System.out.println("第" + i + "活动被选中，其开始时间为：" + s[i] + "，结束时间为：" + f[i]);
            }
        }

    }

}

转载于： 活动安排问题

二、贪心算法2 ： 订单问题

骑手有 n 个订单，每个订单需要时间 t 配送，每个订单有一个截止时间；骑手可以使用技能瞬间配送完成，问最少需要使用几次技能才能把所有订单准时送达。

分析：与活动时间安排思路一致，首先对订单的截至时间进行排序，并存放至deadLine[]数组中，开始时间为 0 ，每送一个订单计算如下 ：

time += t；
//表明此订单超时了
if(time > deadLine[i]) {
	//订单超时，此时就应该使用技能送过去
	res++；
};

三、 贪心算法3 之线段覆盖（lines cover）

题目大意：

在一维空间中告诉你N条线段的起始坐标与终止坐标，要求求出这些线段一共覆盖了多大的长度。

算法思路：

• 其实这就是贪心算法的一个应用，
• 首先，根据线段的起始位置进行从小到大排序。
• 其次，我们分析覆盖长度是怎样计算的：
  • 假如线段1为 s[i] - f[i] ，线段2为 s[j] - f[j] ,如果线段1 与 线段2 相交，也就是 f[i] < s[j] , 那么两个线段之和为： f[j] - s[i] , 同 时将 i = j ，f[i] 成为新的线段尾部。
  • 但是需要注意的是： 如果存在线段1 包括 线段2 的情况也需要单独判断。
  • 假如 线段1 与 线段2 没有相交，那么新的长度就是： 两个线段长度之和。
• 总结： 说白了就是判断子区间是否重合的一个思想，但是从小到大排序，并且从小到大依次判断这样的思想是贪心的思路。

四、贪心算法4：2335. 装满杯子需要的最短总时长

现有一台饮水机，可以制备冷水、温水和热水。每秒钟，可以装满 2 杯 不同 类型的水或者 1 杯任意类型的水。

给你一个下标从 0 开始、长度为 3 的整数数组 amount ，其中 amount[0]、amount[1] 和 amount[2] 分别表示需要装满冷水、温水和热水的杯子数量。返回装满所有杯子所需的 最少 秒数。

算法思路：

这是一道很经典的贪心问题，贪心体现在两方面：

• 每次尽可能的贪心装满两杯。
• 贪心的使得装满两杯的次数最多。
• 也就是每次我都要选取杯子数量最多的两种来装，这样就保证我装满两杯的次数最多。

本题也是结合排序的手段来进行贪心选择数量最多的两杯水，这里我用了优先级队列维护的大根堆来保存数量最多的top1 与 top2两杯。有简单的算法，但都离不开排序。

public class Solution01 {
    public int fillCups(int[] amount) {
        PriorityQueue<Integer> queue = new PriorityQueue<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
        //记录非0个数
        int count = 0;
        for (int i = 0; i < 3; i++) {
            if (amount[i] == 0) {
                continue;
            } else {
                count++;
                queue.offer(amount[i]);
            }
        }
        if (count == 1) {
            return queue.peek();
        }
        int res = 0;
        while (queue.size() != 0 && queue.peek() != 0) {
            if (queue.size() == 1) {
                res += queue.peek();
                return res;
            }
            int top1 = queue.poll();
            int top2 = queue.poll();
            top1--;
            top2--;
            res++;
            if (top2 != 0) {
                queue.offer(top2);
            }
            if (top1 != 0) {
                queue.offer(top1);
            }
        }
        return res;
    }
}

四、贪心算法4 ： 1353. 最多可以参加的会议数目

这个题目需要多加一个判断条件，也就是排序的时候，如果存在相交和重合的情况，还有一些特殊情况，也就是说：如果，能够在第一段时间区间内把所有相交和重叠任务都完成，这个有点问题。

也是很贪心的思想：

首先，选取最先开始的会议参加。

其次，选取已经开始的会议参加（因为我们尽可能贪心的先把开始的会议参加，没开始的会议不参加。

其次，在已经开始的会议里面我们选择，结束时间最早的会议参加。（这样也是贪心的思想，先把快结束的会议参加，防止到时候不能参加了，同时给后面的没结束的会议留出时间）；

最后，将已经结束的会议踢出去队列。