贪心 — 区间问题_区间选点_区间分组_区间覆盖

①区间选点

实现步骤

1.将每个区间按右端点从小到大排序

2.从前往后依次枚举每个区间

如果当前区间包含点，则pass
否则，选择当前区间的右端点

ans：合法方案的最小值
cnt：一种合法方案

证明：显然，所有合法方案的最小值 ans <= cnt

看是否 ans >= cnt ：
考虑最坏情况，选择的每个点都只包含在本区间，即每个区间都需要选其右端点；若要包含cnt个区间，ans至少为cnt，即ans >= cnt

一定得到最优解

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 100010;
int n;

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

int main()
{
    cin >> n;
    for(int i = 0; i < n; i++)
    {
        int a,b;
        cin >> a >> b;
        range[i] = {a,b};
    }
    //将区间按右端点从小到大排序
    sort(range,range+n);
    
    //res代表选择点数，初始无ed，可设为负无穷（小于任何一个左端点）
    int res = 0, ed = -2e9;
    for(int i = 0; i < n; i++)
    {
   		//当前区间左端点＞上一个区间所选点，说明该点不包含在当前区间，需要选点+更新ed
        if(range[i].l > ed){
            res++;
            ed = range[i].r;
        }
    }
    cout << res << endl;
    
    return 0;
}

②区间分组

实现步骤

1.将每个区间按左端点从小到大排序

2.从前往后处理每个区间，判断能否将其放到某个现有的组中

（组内的右端点的最大值是否大于等于当前左端点=>有交集，不能放）

（可以用小根堆存放每个组的右端点的最大值，只需要判断最小的右端点的最大值和当前区间的左端点大小即可，若当前区间左端点<=最小的右端点的最大值，那么它一定也小于其他组的右端点的最大值）

如果不存在这样的组，则开新组，然后再将其放进去

如果存在这样的组（随便选择一个即可），将其放在这个组里，更新右端点最大值

证明：

• ans<=cnt （cnt：组的数量）

按照该方法得到的cnt一定是一个合法方案，ans是所有合法方案的最小值

• ans>=cnt

枚举到某个区间时，和前面cnt-1个区间都有交点，则当前这个区间也应单开一个组，所有的区间都有应该单独在一个组

#include <iostream>
#include <queue>
#include <cstring>
#include <algorithm>
#include <queue>

using namespace std;

const int N = 100010;
int n;

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

int main()
{
    //小根堆存每个组的Max_r
    priority_queue<int, vector<int>, greater<int> > heap;
    cin >> n;
    for(int i = 0; i < n; i++)
    {
        int l,r;
        cin >> l >> r;
        range[i] = {l,r};
    }
    sort(range,range+n);

    for(int i = 0; i < n; i++)
    {
        auto r = range[i];
        //堆内无组 或者 该区间的左端点 <= min(Max_r) ->有交集 需要新建组，即把当前区间的右端点加入小根堆
        if(heap.empty() || r.l <= heap.top()) heap.push(r.r);
        else{
            //可以将当前区间加入组内，即把小根堆内min(Max_r)弹出，将新加入的区间的右端点加入小根堆，作为该组新的最大右端点值
            heap.pop();
            heap.push(r.r);
        }
    }
    cout << heap.size() << endl;

    return 0;
}

③ 区间覆盖

实现步骤

1.将所有区间按左端点从小到大排序

2.从前往后依次枚举每个区间，在所有能覆盖start的区间内中，选择右端点最大的区间

然后将起点start更新为右端点的最大值

证明：

当前算法计算出的cnt个区间一定可以替换最优解ans中的每个区间（当前算法每次取的是最长的），而且不会增加区间的数量，那么ans=cnt。

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

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

int main()
{
    cin >> st >> ed >> n;
    int res = 0;
    bool success = false;
    for(int i = 0; i < n; i++)
    {
        int l,r;
        cin >> l >> r;
        range[i] = {l,r};
    }
    sort(range,range+n);
    //每次循环，寻找一个符合算法条件的st，直至r >= ed，完成覆盖
    for(int i = 0; i < n; i++)
    {
        int j = i;
        int r = -2e9;
        //r = 所有小于左端点的区间中 最大的右端点的值
        //j相当于在该轮循环在比较的区间，最后j的值为比较的区间+1，即为下一轮i的值
        while(j < n && range[j].l <= st)
        {
            r = max(r,range[j].r);
            j++;
        }
        
        if(r < st) 
        {
            res = -1;
            break;
        }
        res ++;
        
        if(r >= ed)
        {
            success = true;
            break;
        }
        
        st = r;
        
        i = j - 1;
    }
    if(!success) res = -1;
    cout << res << endl;
    
    return 0;
}