【贪心】区间问题：选点、分组、覆盖以及最大不相交数量

贪心问题是一种很复杂的问题，因为没有一个固定的做法，基本就是每个问题当场思考。贪心问题可以总结成一句话：要得到整体最优解，先从局部最优解开始。

本篇文章讲解贪心问题中的一类：区间问题，因为这类问题使用频率较大且做法较为统一。

1、区间选点

原题 acwing 区间选点

给定 N 个闭区间 [$a_i$,$b_i$]，请你在数轴上选择尽量少的点，使得每个区间内至少包含一个选出的点。
输出选择的点的最小数量。
位于区间端点上的点也算作区间内。
输入格式
第一行包含整数 N，表示区间数。
接下来 N 行，每行包含两个整数 $a_i$,$b_i$，表示一个区间的两个端点。
输出格式
输出一个整数，表示所需的点的最小数量。
数据范围
1≤N≤10⁵,
−10⁹≤$a_i$≤$b_i$≤10⁹
输入样例：

3
-1 1
2 4
3 5

输出样例：

2

做法就是：

1. 先把所有区间按右端点从小到大排序；
2. 依次枚举每个区间，如果已经包含一个区间内的点，那么就pass；否则就把点选为右端点；
3. 最后选出的点数就是答案。

道理就是这样，凭个人感觉差不多能感觉这样做是对的。因为每次选的都是右端点，也即尽可能地往其他区间上凑，每次都刻意地去贴近其他区间，到最后就能得到正确答案。但是这样说是不严谨的，下面给出一个严谨的证明。

那么只要按照上面的流程用代码实现即可：

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 100010;

struct Range{
    int l, r;
    
    //重载小于号，以右端点排序
    bool operator< (const Range &W)const
    {
        return r < W.r;
    }
}range[N];

int n;

int main()
{
    cin >> n;
    
    for (int i = 0; i < n; i ++ )
    {
        int l, r;
        scanf("%d%d", &l, &r);
        range[i] = {l, r};
    }
    
    //以右端点排序
    sort(range, range + n);
    
    //res记录答案，ed记录当前选点
    int res = 0, ed = -2e9;
    for (int i = 0; i < n; i ++ )
    	//如果区间左端点都大于当前选点，说明选点不在当前区间
        if (range[i].l > ed)
        {
        	//那么就再选一个新的点
            res ++ ;
            ed = range[i].r;
        }
        
    cout << res << endl;
    
    return 0;
}

2、最大不相交区间数量

原题acwing 最大不相交区间数量

给定 N 个闭区间 [$a_i$,$b_i$]，请你在数轴上选择若干区间，使得选中的区间之间互不相交（包括端点）。
输出可选取区间的最大数量。
输入格式
第一行包含整数 N，表示区间数。
接下来 N 行，每行包含两个整数 $a_i$,$b_i$，表示一个区间的两个端点。
输出格式
输出一个整数，表示可选取区间的最大数量。
数据范围
1≤N≤10⁵,
−10⁹≤$a_i$≤$b_i$≤10⁹
输入样例：
3
-1 1
2 4
3 5
输出样例：
2

这道题目和区间选点完全一样。至于为什么一样呢，这里只给出字面上的解释：因为有公共点就说明这几个区间是相交的，那么要尽可能的减少相交的区间，就尽可能的减少公共点。所以最少有几个公共点就说明最多有几个互不相交的区间。具体证明较为复杂，不做详细说明。
本题题解和上一题完全一样，复制粘贴即可通过。

3、区间分组

原题 acwing 区间分组

给定 N 个闭区间 [$a_i$,$b_i$]，请你将这些区间分成若干组，使得每组内部的区间两两之间（包括端点）没有交集，并使得组数尽可能小。
输出最小组数。
输入格式
第一行包含整数 N，表示区间数。
接下来 N 行，每行包含两个整数 $a_i$,$b_i$，表示一个区间的两个端点。
输出格式
输出一个整数，表示最小组数。
数据范围
1≤N≤10⁵,
−10⁹≤$a_i$≤$b_i$≤10⁹
输入样例：
3
-1 1
2 4
3 5
输出样例：
2

做法：

1. 按左端点从小到大排序；
2. 从前往后依次枚举区间，判断每个区间是否能放到某个组中
   判断方法：已有的所有组中一定有一个右端点最小值，判断一下当前区间的左端点是否大于最小值，如果大于，就说明可以放到组中（因为左端点大于某个组的右端点，说明不相交）；否则，说明这个区间和当前所有组都有交集（因为最小的右端点都和它有交集了，那其他右端点一定也会有），这时候就要新开一个组了。

下面给出一个证明：

由于这里要记录所有组右端点的最小值，所以考虑用小根堆来实现。其中堆中存的是所有组的右端点。给出题解：

#include <iostream>
#include <algorithm>
#include <queue>
#include <vector>

using namespace std;

const int N = 100010;

struct Range{
    int l, r;
    
    bool operator< (const Range &W)const
    {
        return l < W.l;
    }
}range[N];

int n;

int main()
{
    cin >> n;
    
    for (int i = 0; i < n; i ++ )
    {
        int l, r;
        scanf("%d%d", &l, &r);
        range[i] = {l, r};
    }
    
    sort(range, range + n);
    
    priority_queue<int, vector<int>, greater<int>> heap;
    for (int i = 0; i < n; i ++ )
    {
        auto t = range[i];
        if (heap.empty() || heap.top() >= t.l) heap.push(t.r);
        else
        {
            heap.pop();
            heap.push(t.r);
        }
    }
    
    cout << heap.size() << endl;
    
    return 0;
}

4、区间覆盖

原题 acwing 区间覆盖

给定 N 个闭区间 [$a_i$,$b_i$]，请你将这些区间分成若干组，使得每组内部的区间两两之间（包括端点）没有交集，并使得组数尽可能小。
输出最小组数。
输入格式
第一行包含整数 N，表示区间数。
接下来 N 行，每行包含两个整数 $a_i$,$b_i$，表示一个区间的两个端点。
输出格式
输出一个整数，表示最小组数。
数据范围
1≤N≤10⁵,
−10⁹≤$a_i$≤$b_i$≤10⁹
输入样例：
3
-1 1
2 4
3 5
输出样例：
2

步骤：

1. 先按左端点排序；
2. 依次枚举所有区间，选择能覆盖指定区间左端点的区间里，右端点最远的，并且将指定区间左端点更新为此最远的右端点。

字面上来说，就是每次找一个能覆盖的，并且覆盖的最多的，一直这样找下去就能找到最优解。具体证明较为复杂，不过这道题目也比较通俗易懂，所以直接给出题解：

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 100010;

struct Range{
    int l, r;
    
    bool operator< (const Range &W)const
    {
        return l < W.l;
    }
}range[N];

int n;

int main()
{
    int st, ed;
    cin >> st >> ed;
    
    cin >> n;
    
    for (int i = 0; i < n; i ++ )
    {
        int l, r;
        scanf("%d%d", &l, &r);
        range[i] = {l, r};
    }
    
    sort(range, range + n);
    
    int res = 0;
    bool flag = false;
    
    for (int i = 0; i < n; i ++ )
    {
        int j = i, r = -2e9;
        while (j < n && range[j].l <= st)
        {
            r = max(r, range[j].r);
            j ++ ;
        }
        
        //如果所有区间的最大右端点都小于左端点，那就说明无法覆盖
        if (r < st)
        {
            res = -1;
            break;
        }
        
        res ++ ;
        //覆盖到右端点后，即完成
        if (r >= ed)
        {
            flag = true;
            break;
        }
        
        st = r;
        //下一次迭代要从所选区间的下一个开始，这里j其实是所选区间的下一个，并且i会在本次迭代后自增
        //举个例子：所选区间是3，那么此时j是4，因此i是3，但是因为for语句的特性，i会自增，也即4
        i = j - 1;
    }
    
    if (!flag) res = -1;
    cout << res << endl;
    
    return 0;
}

总结

贪心问题一般就是只考虑当前情况的最优方式，累计起来就是整体的最优方式。遇到贪心问题，一般过程为：

1. 思考每一次怎样做是最优的；
2. 自己设置几个样例检验一下做法的正确性，如果正确就直接写，如果不正确就换策略；
3. 贪心题目一般不考察证明，因为实际写题的时候没有时间证明，只要感觉对，直接试样例即可；
4. 一定要自己找几组样例，因为题目所给样例可能具有迷惑性

而对于区间问题，一般先按左端点或右端点排序，再思考具体做法。