贪心(一)

区间问题

区间选点

首先我们将各个区间按照其最右端点值从小到大排序
其次我们按序选出每个区间最右端点的值作为该区间的点，在这个过程中，倘若该点同时被其他区间所包含，则直接跳过该区间,最后选出的点的数量cnt作为最后的答案
我们考虑最小值ans那么显然有cnt>=ans
考虑一个两两互不相交的区间组合，那么以此方案选出的cnt<=ans
由此我们得出cnt=ans

#include<iostream>
#include<algorithm>

using namespace std;

const int N=100010;

int n;

struct Range{
    
    int l,r;
    
    bool operator < (const Range &a)const{    //按照右端点排序
        
        return r<a.r;
    }
}range[N];

int main(){
    
    cin>>n;
    
    for(int i=0;i<n;i++){
        
        int l,r;
        
        cin>>l>>r;
        
        range[i]={l,r};
    }
    
    sort(range,range+n);
    
    int res=0,lp=-2e9;       //初始化答案，上一个选定的端点值
    
    for(int i=0;i<n;i++){
        
        if(lp<range[i].l){
            
            res++;
            
            lp=range[i].r;
        }
    }
    
    cout<<res;
}

最大不相交区间数量

完全同上一题，换了一种问法

#include<iostream>
#include<algorithm>

using namespace std;

const int N=100010;

int n;

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

int main(){
    
    cin>>n;
    
    for(int i=0;i<n;i++){
        
        int l,r;
        
        cin>>l>>r;
        
        range[i]={l,r};
    }
    
    sort(range,range+n);
    
    int res=0,lp=-2e9;
    
    for(int i=0;i<n;i++){
        
        if(lp<range[i].l){
            
            res++;
            
            lp=range[i].r;
        }
    }
    
    cout<<res;
}

区间分组

首先我们将所有区间按照左端点值L(i)从小到大排序
对于每一个区间，我们根据它的左端点的值与当前所有组的右端点最大值max_R进行比较，如果满足L(i)>max_R，则将其插入到当前组，如果不存在满足条件的组，则开一个新的组
对于这一题来说，如果当前所有组中的max_R中最小的一个同样满足L(i)>max_R，那么必须开辟新的组，我们用小根堆priority_queue来存储当前最小的max_R

得到最后答案cnt和满足题目条件的最小值ans
1.显然可以得出ans<=cnt
2.其次假定一个区间最左端点L(i)和已经选定的cnt-1个组，倘若L(i)是最后一个选定的组cnt则一定与前cnt-1个组存在交集，则交点一定是L(i)，那么则把这cnt个区间分开就至少需要cnt个组，则cnt<=ans

#include<iostream>
#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(){
    
    cin>>n;
    
    for(int i=0;i<n;i++){
        
        int l,r;
        
        cin>>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 now =range[i];
        
        if(heap.empty()|| heap.top()>=now.l)heap.push(now.r);        //如果不存在可以插入的组，则开辟新的组，否则插入当前组
        
        else {
            
            heap.pop();
            
            heap.push(now.r);
        }
    }
    
    cout<<heap.size();
}

区间覆盖

首先我们将所有区间按照左端点值L(i)从小到大排序
其次根据被覆盖区间的起始点start，顺次找到可以覆盖该起始点，并且覆盖最多(向右延伸最多)的一个区间作为选择区间,然后将start更新为该区间右端点，最后所选一组区间就是答案cnt

#include<iostream>
#include<algorithm>

using namespace std;

const int N=1e5+10;

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;
        
        cin>>l>>r;
        
        range[i]={l,r};
    }
    
    sort(range,range+n);
    
    int res=0,success=false;      //定义最后选择的区间数量，以及是否成功覆盖flag
    
    for(int i=0;i<n;){
        
        int j=i,r=-2e9;
        
        while(range[j].l<=st && j<n){       //对于每一个小于等于当前起始点的区间，找出其中右端点最大值
            
            r=max(r,range[j].r);
            
            j++;
        }
        
        if(r<st)break;                     //如果最大右端点小于起始点则不可能覆盖
        
        res++;
        
        if(r>=ed){                        //如果最大右端点已经超过结尾则已经成功覆盖
            
            success=true;
            
            break;
        }
        
        st=r;                               //覆盖完一段后更新起始点
        
        i=j;
    }
    
    if(success)cout<<res;
    
    else cout<<"-1";
}