所谓贪心，就是不断寻找局部最优解

    // //1.区间选点：给n个区间，在数轴中选尽量少的点，使每个区间至少包含一个选出的点
    // //2.最大不相交区间数量：给n个区间，在数轴中选若干个区间，使各区间间互不相交

    // 思路：1.将区间右端点从小到大排序
    //       2.从前往后枚举每一个区间
    //         i如果当前区间中已经有包含点，pass
    //         ii否则，选择区间的右端点

    #include<iostream>
    #include<algorithm>

    using namespace std;
    const int N=10010;
    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 l,r;
            cin>>l>>r;
            range[i]={l,r};
        }
        //排序区间
        sort(range,range+n);

        int res=0;
        int ed=-2e9;
        for(int i=0;i<n;i++)
            if(range[i].l>ed)
            {
                res++;
                ed=range[i].r;
            }

        cout<<res;
        return 0;
    }

    // 3.区间分组：给定n个区间，将n个区间俩俩分组，每组内部的区间之间没有交集，并使组数最小
    // 思路：1.将所有区间按左端点从小到大排序
    //       2.从前往后处理每个区间：判断能否将其放在现有的组中
    //         定义L[i],是新区间左端点，max_r,是组中右端点最大的值(取最小的最大值进行判断，因此需要小根堆)
    //         i.如果不存在这样的组，则开新组，将其放进去
    //         ii.如果存在这样的组，将其放进去，并能更新当前的Max_r

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

    using namespace std;
    const int N=100100;

    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 r=range[i];
            //如果组数为0或者最小的最大值大于新集合的左边（必定相交）
            if(heap.empty()||heap.top()>=r.l)
            //加入新组
            heap.push(r.r);
            else//可以新集合可以加入一个组 
            {
                heap.pop();
                heap.push(r.r);
            }
        }
        cout<<heap.size()<<endl;
        return 0;
    }

    // 4.区间覆盖：给定一个线段区间和n个闭区间，用较少区间将线段区间覆盖
    // 思路：1.将所有区间按左端点从小到大排序
    //       2.从前往后依次枚举每个区间，在所有能覆盖start的区间中，
    //         选择右端点最大的区间，然后将start更新成右端点的最大值
    #include<iostream>
    #include<algorithm>

    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()
    {
        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;
        bool success=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)
            {
                success=true;
                break;
            }

            st=r;
            i=j-1;//回溯继续
        }
        if(!success)res=-1;
        cout<<res<<endl;
        return 0;
    }