ACM五大贪心区间问题总结

1.

区间合并（将若干有交集的区间合并为一个区间）

思路：区间按右端点排序，对于当前一段已经合并完的区间，设该区间的两个端点为st，ed。若下一个线段x的左端点比当前的区间的右端点还大（及ed<x.l）则开一个新的区间，否则将该线段合并入这个区间内并更新ed（ed=max(ed,x.r)，实际操作中只需要更新即可）；

模板代码：

#include <iostream>
#include <algorithm>
#define l first
#define r second
using namespace std;
typedef pair<int,int> PII;
vector<PII>s,res;
int main(){
    int n;
    cin>>n;
    for(int i=0;i<n;i++){
        int l,r;
        cin>>l>>r;
        s.push_back({l,r});
    }
    
    sort(s.begin(),s.end());
    int st=-2e9,ed=-2e9;
    for(auto x:s){
        if(ed<x.l){
            if(st!=-2e9) res.push_back({st,ed});
            st=x.l,ed=x.r;
        }
        else ed=max(ed,x.r);
    }
    
    if(st!=-2e9) res.push_back({st,ed});
    
    cout<<res.size()<<endl;
}

2.（这两个不一样的问题，模板代码却完全一样）

区间选点（给定若干个区间，要求选最少的点去覆盖所有区间）

最大区间不相交数量（给定若干个区间，选出部分区间，使得这部分区间互不相交，求这部分区间最大可以是多少）

思路：所有区间按右端点排序，对于当前区间的右端点ed,若下一个区间的左端点比ed大了，说明必须再选一个点，令这个心选的点为这个新区间的的右端点。

模板代码：

//区间按右端点排序(ps:选点越靠右越好，这样就可以覆盖更多的区间)
//先选择一个初始区间的右端点，如果当前区间已经包含该点，则pass；
//否则选择当前区间的右端点
#include <iostream>
#include <algorithm>
using namespace std;
const int N=100010;
struct node{
    int l,r;
    bool operator<(const node &a)const
    {
        return r<a.r;
    }
}a[N];
int main(){
    int n;
    scanf("%d",&n);
    for(int i=0;i<n;i++){
        cin>>a[i].l>>a[i].r;
    }
    sort(a,a+n);
    int ans=0,ed=-2e9;
    for(int i=0;i<n;i++){
        if(a[i].l>ed){
            ans++;
            ed=a[i].r;
        }
    }
    cout<<ans<<endl;
}

3.

区间分组（给定若干区间，这些区间将这些区间分成若干组，保证组内互不相交，求最少分多少组）

思路：区间按左端点排序，我们用一个优先对列来存储每一个组内最右端区间的右端点，如果对于一个新的区间，连当前所有组里面右端点最小的那个组都比这个新区间的左端点大，那么说明必须开一个新的组（直接将这个区间的右端点push进队列）,否则就接到右端点最小的那个组里面（先将q.pop，然后再将该区间的右端点push进去）；

模板代码：

/*1.区间左端点排序
2.从前往后处理所有区间
判断能否将其放到某个现有的组当中，判断条件 l[i]>max_r
(1)如果不存在这样的组，则开新组，然后再将其放进
(2)如果存在，将其放进去，并跟新该组的max_r*/
#include <iostream>
#include <queue>
#include <algorithm>
using namespace std;
const int N=100010;
struct node{
    int l,r;
    bool operator<(const node &a)const
    {
        return l<a.l;
    }
}a[N];
int main(){
    int n;
    cin>>n;
    for(int i=0;i<n;i++)cin>>a[i].l>>a[i].r;
    sort(a,a+n);
    priority_queue<int,vector<int>,greater<int> >q;//堆顶是最小值
    for(int i=0;i<n;i++){
        if(q.empty()||q.top()>=a[i].l)q.push(a[i].r);//最小的右端点都会与当前区间相交，则必须开一个新的点。
        else{
            q.pop();//最小的右端点 不会与当前点相交，加入最小的右端点的组中，所以要删掉原来的右端点
            q.push(a[i].r);
        }
    }
    cout<<q.size()<<endl;
} 

4.

区间覆盖（给定若干区间，要求选取最少的区间使得这些区间可以完全覆盖掉某个范围的区间）

思路：区间左端点排序，对于当前我们已经覆盖到了st的位置，那么下一个区间我们就选择包含st的且右端点最大的区间，然后用双指针实现。

模板代码：

/*
1.区间左端点排序
2.设当前已覆盖至st,寻找能覆盖st的右端点最远的线段，
用这个右端点更新st,重复上述过程。
*/
#include <iostream>
#include <algorithm>
using namespace std;
const int N=100010;
struct node{
    int l,r;
    bool operator<(const node &a)const
    {
        return l<a.l;
    }
}a[N];
int main(){
    int n,st,ed;
    cin>>st>>ed;
    cin>>n;
    for(int i=0;i<n;i++)cin>>a[i].l>>a[i].r;
    sort(a,a+n);
    int res=0,flag=0;
    for(int i=0;i<n;i++){
        int j=i,r=-2e9;
        while(j<n&&a[j].l<=st){
            r=max(r,a[j].r);
            j++;
        }
        if(r<st)break;
        res++;
        if(r>=ed){
            flag=1;
            break;
        }
        st=r;
        i=j-1;
    }
    if(flag)cout<<res<<endl;
    else cout<<-1<<endl;
}