贪心算法（greedy algorithm）

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

贪心算法不是对所有问题都能得到整体最优解，关键是贪心策略的选择。贪心选择是指所求问题的整体最优解可以通过一系列局部最优的选择，即贪心选择来达到。

算法思路

贪心算法一般按如下步骤进行：

①建立数学模型来描述问题   。

②把求解的问题分成若干个子问题  。

③对每个子问题求解，得到子问题的局部最优解  。

④把子问题的解局部最优解合成原来解问题的一个解  。

贪心算法是一种对某些求最优解问题的更简单、更迅速的设计技术。贪心算法的特点是一步一步地进行，常以当前情况为基础根据某个优化测度作最优选择，而不考虑各种可能的整体情况，省去了为找最优解要穷尽所有可能而必须耗费的大量时间。贪心算法采用自顶向下，以迭代的方法做出相继的贪心选择，每做一次贪心选择，就将所求问题简化为一个规模更小的子问题，通过每一步贪心选择，可得到问题的一个最优解。虽然每一步上都要保证能获得局部最优解，但由此产生的全局解有时不一定是最优的，所以贪心算法不要回溯   。

算法特性

贪心算法可解决的问题通常大部分都有如下的特性：

1、有一个以最优方式来解决的问题。为了构造问题的解决方案，有一个候选的对象的集合：比如不同面值的硬币  。

2、随着算法的进行，将积累起其他两个集合：一个包含已经被考虑过并被选出的候选对象，另一个包含已经被考虑过但被丢弃的候选对象  。

3、有一个函数来检查一个候选对象的集合是否提供了问题的解答。该函数不考虑此时的解决方法是否最优   。

4、还有一个函数检查是否一个候选对象的集合是可行的，即是否可能往该集合上添加更多的候选对象以获得一个解。和上一个函数一样，此时不考虑解决方法的最优性 。

5、选择函数可以指出哪一个剩余的候选对象最有希望构成问题的解。

6、最后，目标函数给出解的值 。

使用条件

利用贪心法求解的问题应具备如下2个特征   。

1、贪心选择性质

一个问题的整体最优解可通过一系列局部的最优解的选择达到，并且每次的选择可以依赖以前作出的选择，但不依赖于后面要作出的选择。这就是贪心选择性质。对于一个具体问题，要确定它是否具有贪心选择性质，必须证明每一步所作的贪心选择最终导致问题的整体最优解  。

2、最优子结构性质

当一个问题的最优解包含其子问题的最优解时，称此问题具有最优子结构性质。问题的最优子结构性质是该问题可用贪心法求解的关键所在。在实际应用中，至于什么问题具有什么样的贪心选择性质是不确定的，需要具体问题具体分析 。

解题策略

贪心算法不从整体最优上加以考虑，所做出的仅是在某种意义上的局部最优选择。使用贪心策略要注意局部最优与全局最优的关系，选择当前的局部最优并不一定能推导出问题的全局最优。贪心策略解题需要解决以下两个问题：

1、该问题是否适合使用贪心策略求解，也就是该问题是否具有贪心选择性质  ；

2、制定贪心策略，以达到问题的最优解或较优解   。

要确定一个问题是否适合用贪心算法求解，必须证明每一步所作的贪心选择最终导致问题的整体最优解。证明的大致过程为：首先考察问题的一个整体最优解，并证明可修改这个最优解，使其以贪心选择开始，做了贪心选择后，原问题简化为规模更小的类似子问题。然后用数学归纳法证明通过每一步做贪心选择，最终可得到问题的整体最优解 。

存在问题

贪心算法也存在如下问题： 

1、不能保证解是最佳的。因为贪心算法总是从局部出发，并没从整体考虑   ；

2、贪心算法一般用来解决求最大或最小解  ；

3、贪心算法只能确定某些问题的可行性范围  。

应用实例

例如，平时购物找零钱时，为使找回的零钱的硬币数最少，不要求找零钱的所有方案，而是从最大面值的币种开始，按递减的顺序考虑各面额，先尽量用大面值的面额，当不足大面值时才去考虑下一个较小面值，这就是贪心算法   。

有很多经典的应用，比如霍夫曼编码，普利姆和克鲁斯卡尔最小生成树算法，还有迪杰斯特拉单源最短路径算法，都是使用了这种思维。

无重叠区间

给定一个区间的集合 intervals ，其中 intervals[i] = [starti, endi] 。返回 需要移除区间的最小数量，使剩余区间互不重叠 。

示例 1:

输入: intervals = [[1,2],[2,3],[3,4],[1,3]]
输出: 1
解释: 移除 [1,3] 后，剩下的区间没有重叠。

示例 2:

输入: intervals = [ [1,2], [1,2], [1,2] ]
输出: 2
解释: 你需要移除两个 [1,2] 来使剩下的区间没有重叠。

示例 3:

输入: intervals = [ [1,2], [2,3] ]
输出: 0
解释: 你不需要移除任何区间，因为它们已经是无重叠的了。
 

首先将所有的区间按照起始位置进行递增排序

1.如果是[1,2],[2,3]不冲突，就保留。

2.如果[1,2],[1,3]也就是后面一个区间包裹住了前面一个区间，我们就将后面这个区间删除

3.如果是 [1,3][2,4]，就将后面一个区间删除，为后面的区间留出更大的区间

bool cmp(const vector<int>& a, const vector<int>& b)
{
//按起点递增排序
    return a[0] < b[0];
} 
class Solution {
public:
    int eraseOverlapIntervals(vector<vector<int>>& intervals) {
        if (intervals.size() == 0) {
            return 0;
        } //按起点递增排序
        sort(intervals.begin(), intervals.end(), cmp);
        int end = intervals[0][0], prev = 0, count = 0;
        for (int i = 1; i < intervals.size(); i++) {
//前一个事件的结束时间比后一个事件的开始时间晚
            if (intervals[prev][1] > intervals[i][0]) {
//前一个时间的结束时间比后一个事件的结束时间晚
                if (intervals[prev][1] > intervals[i][1]) {
//情况2
                    prev = i;
                } //情况3
                count++;
            } else {
//情况1
//前一个事件的结束时间比后一个时间的起始时间早
                prev = i;
            }
        } return count;
    }
};

活动选择

有n个需要在同一天使用同一个教室的活动a1, a2, …, an，教室同一时刻只能由一个活动使用。每个活动a[i]都有一个开始时间s[i]和结束时间f[i]。

一旦被选择后，活动a[i]就占据半开时间区间[s[i],f[i])。如果[s[i],f[i])和[s[j],f[j])互不重叠，a[i]和a[j]两个活动就可以被安排在这一天。求使得尽量多的活动能不冲突的举行的最大数量。

                贪心：每次选取结束时间最早的活动，可以得到最优解。

#include<iostream>
#include<algorithm>
#include <vector>
using namespace std;
bool cmp(const pair<int,int>& a, const pair<int,int>& b)
{
    return a.second < b.second;
}
int greedyActivitySelector(const vector<pair<int,int>>& act)
{
//贪婪策略：每次选择最早结束的活动
//num是统计举办的活动个数
    int num = 1, i = 0;
    for (int j = 1; j < act.size(); j++)
    {
        //后一个活动的开始时间小于前一个活动的结束时间
        if (act[j].first >= act[i].second)
        {
            i = j;
            num++;
        }
    }
    return num;
}
int main()
{
    int number;
    cin >> number;
    vector<pair<int, int>> act(number);
    int idx = 0;
    for (int i = 0; i < act.size(); ++i)
    {
        cin >> act[i].first >> act[i].second;
    } //按照活动截止时间从小到大排序
    sort(act.begin(), act.end(), cmp);
    int ret = greedyActivitySelector(act);
    cout << ret << endl;
}

多机调度问题

某工厂有n个独立的作业，由m台相同的机器进行加工处理。作业i所需的加工时间为ti，任何作业在被处理时不能中
断，也不能进行拆分处理。现厂长请你给他写一个程序：算出n个作业由m台机器加工处理的最短时间
输入
第一行T（1<T<100)表示有T组测试数据。每组测试数据的第一行分别是整数n，m（1<=n<=10000，
1<=m<=100），接下来的一行是n个整数ti（1<=t<=100)。
输出
所需的最短时间