贪心算法（基础版）

1.区间选点

给定 N个闭区间 [ai,bi]，请你在数轴上选择尽量少的点，使得每个区间内至少包含一个选出的点。

输出选择的点的最小数量。

位于区间端点上的点也算作区间内。

输入格式

第一行包含整数 N，表示区间数。

接下来 N 行，每行包含两个整数 ai,bi，表示一个区间的两个端点。

输出格式

输出一个整数，表示所需的点的最小数量。

数据范围

输入样例：

3
-1 1
2 4
3 5

输出样例：

2

#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 r < W.r;
    }
}range[N];

int main()
{
    scanf("%d", &n);
    for (int i = 0; i < n; i ++ ) scanf("%d%d", &range[i].l, &range[i].r);

    sort(range, range + n);

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

    printf("%d\n", res);

    return 0;
}

2.区间分组

给定 N 个闭区间 [ai,bi]，请你将这些区间分成若干组，使得每组内部的区间两两之间（包括端点）没有交集，并使得组数尽可能小。

输出最小组数。

输入格式

第一行包含整数 N，表示区间数。

接下来 N 行，每行包含两个整数 ai,bi，表示一个区间的两个端点。

输出格式

输出一个整数，表示最小组数。

数据范围

输入样例：

3
-1 1
2 4
3 5

输出样例：

2

自己的思路：

1.要求得每组内部的区间两两之间（包括端点）没有交集，即有交集的必不能在一个组内

2.求出最多相交区间的个数，即为答案（这里的相交，即在这个组内的每一个区间都互相相交）

这样求得的解一定是一个合法解：求得是最多相交区间的个数 ,则其他得相交区间个数<max，所需要放的组数<max

证明：

最优解<=贪心解 最优解是最小组数，而贪心解是一个合法解 ，所以：最优解<=贪心解

最优解>=贪心解 贪心解分的组数=最多相交区间的个数x，而这相交得x个区间必定不可能放在一起，所以最优解>=贪心解

所以最优解==贪心解

接下来，就要解决怎么求得 最多相交区间的个数（即所有区间(除自己外)与自己相交的区间个数） ，如果直接遍历是 O(n^2),超时了。

但是这里我们可以用差分， 两个相交的区间必定是有一点是重合的，可以统计整个区间内每个点出现的次数，求最大值=最多相交区间的个数 ,用差分数组统计一下，每个点出现次数，在求一遍前缀和即可。

由于−1e9≤ai≤bi≤1e9，所以要离散化一下

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<vector>
#include<map>
using namespace std;
const int N=2e5+100;
map<int,int>q;  //差分数组
int res=0,n;
int main()
{
    cin>>n;
    while(n--)
    {
        int a,b;
        cin>>a>>b;
        q[a]++;
        q[b+1]--;
    }
    int s=0;  //求前缀和
    for(auto x=q.begin();x!=q.end();x++)
    {
        s+=x->second;
        res=max(s,res);      
    }
    cout<<res;
    return 0;
}

#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()
{
    scanf("%d", &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 r = range[i];
        if (heap.empty() || heap.top() >= r.l) heap.push(r.r);
        else
        {
            heap.pop();
            heap.push(r.r);
        }
    }

    printf("%d\n", heap.size());

    return 0;
}

3.区间覆盖

给定 N 个闭区间 [ai,bi] 以及一个线段区间 [s,t]，请你选择尽量少的区间，将指定线段区间完全覆盖。

输出最少区间数，如果无法完全覆盖则输出 −1。

输入格式

第一行包含两个整数 s 和 t，表示给定线段区间的两个端点。

第二行包含整数 N，表示给定区间数。

接下来 N 行，每行包含两个整数 ai,bi，表示一个区间的两个端点。

输出格式

输出一个整数，表示所需最少区间数。

如果无解，则输出 −1。

数据范围

1≤N≤10^5,

−10^9≤ai≤bi≤10^9,

−10^9≤s≤t≤10^9

输入样例：

1 5
3
-1 3
2 4
3 5

输出样例：

2

#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;
    scanf("%d%d", &st, &ed);
    scanf("%d", &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 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;
    printf("%d\n", res);

    return 0;
}