贪心与区间问题

​

区间问题中的贪心策略

---

贪心与证明

算法中的贪心策略：只需要做出当前看来是最好的选择就能获得最好的结果，而不需要考虑整体上的最优。

其关键在于贪心策略的选择，选择的贪心策略必须具备无后效性，即某个状态以前的过程不会影响以后的状态，只与当前状态有关。

首先需要证明贪心策略是正确的，才可以考虑使用贪心算法解决该问题。常用的有两种：

1. 反证法：假设要选择的方案不是贪心算法所要求的方案，只需要证明将所需要贪心的方案替换掉要选择方案，结果会更好（至少不会更差）。也可以设法构造一些反例尝试推翻贪心。
2. 数学归纳法：每一步的选择都是到目前为止的最优解，一直到最后一步就成为了全局的最优解。

---

区间选点

原题链接： 905. 区间选点 - AcWing题库

【题目描述】

给定 N 个闭区间 [a_i, b_i]，请你在数轴上选择尽量少的点，使得每个区间内至少包含一个选出的点。
输出选择的点的最小数量。
位于区间端点上的点也算作区间内。

【输入格式】
第一行包含整数 N，表示区间数。(1 <= N <= 10⁵)
接下来 N 行，每行包含两个整数 a_i, b_i ，表示一个区间的两个端点。(-10⁹ <= a_i <= b_i <= 10⁹)

【输出格式】

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

【输入样例】

3
-1 1
2 4
3 5

【输出样例】

2

思路：给我们若干个区间，要求我们选出尽可能少的点使得每段区间上至少有一个点。

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

2. 从前往后枚举区间，R 表示上一连续区间的右端点，初始化为无穷小

   • 如果本次区间不能覆盖掉上次区间的右端点，arr[i].l > R

     则需要选择一个新的点并更新右端点，ans++; R = arr[i].r

   • 如果本次区间可以覆盖掉上次区间的右端点，则进行下一轮循环

代码如下：

#include <iostream>
#include <algorithm>
using namespace std;
const int N = 1e5 + 10;

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

int main()
{
    int n;
    cin >> n;
    for (int i = 1; i <= n; i++) 
        cin >> arr[i].l >> arr[i].r;
    
    //按右端点从小到大排序
    sort(arr + 1, arr + 1 + n);
    
    int ans = 0;
    int R = -2e9; //R表示上一连续区间的最右端的点
    for (int i = 1; i <= n; i++)
    {
        if (arr[i].l > R) //如果不能覆盖掉右端点，则点数+1，更新右端点
        {
            ans++;
            R = arr[i].r;
        }
    }
    
    cout << ans << endl;
    
    return 0;
}

---

最大不相交区间数量

原题链接：908. 最大不相交区间数量 - AcWing题库

【题目描述】

给定 N 个闭区间 [a_i, b_i] ，请你在数轴上选择若干区间，使得选中的区间之间互不相交（包括端点）。

输出可选取区间的最大数量。

【输入格式】

第一行包含整数 N，表示区间数。(1 <= N <= 10⁵)

接下来 N 行，每行包含两个整数 a_i, b_i，表示一个区间的两个端点。(-10⁹ <= a_i <= b_i <= 10⁹)

【输出格式】

输出一个整数，表示可选取区间的最大数量。

【输入样例】

3
-1 1
2 4
3 5

【输出样例】

2

思路：与上题一样，换了一种说法，换汤不换药。要使得区间之间互不相交，也就是说，该区间的左端点要大于上一区间的右端点，才能使得区间之间没有重叠部分。使用上一题的代码（按右端点排序）直接交也是可以AC的。

这里提供一种按左端点从小到大排序的写法，原理还是一样：该区间的左端点要大于上一区间的右端点。

代码如下：

#include <iostream>
#include <algorithm>
using namespace std;
const int N = 1e5 + 10;

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

int main()
{
    int n;
    cin >> n;
    for (int i = 1; i <= n; i++)
         cin >> arr[i].l >> arr[i].r;
    
    sort(arr + 1, arr + 1 + n);
    
    int res = 1, R = arr[1].r;
    for (int i = 2; i <= n; i++){
        if (arr[i].l <= R)
            R = min(R, arr[i].r);
        else {
            res++;
            R = arr[i].r;
        }
    }
    
    cout << res << endl;
    
    return 0;
}

---

区间分组

原题链接：906. 区间分组 - AcWing题库

【题目描述】

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

输出最小组数。

【输入格式】

第一行包含整数 N，表示区间数。(1 <= N <= 10⁵)

接下来 N 行，每行包含两个整数 a_i, b_i，表示一个区间的两个端点。(-10⁹ <= a_i <= b_i <= 10⁹)

【输出格式】

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

【输入样例】

3
-1 1
2 4
3 5

【输出样例】

2

思路：要使得每组内部的区间两两之间没有交集，可以转化为能否找到一个组与任意一个组有交集（因为内部不允许有交集，那么有交集一定是在外部），如果没有，则符合条件可以放入该组中，否则新建一个组放入其中，如下图所示：

用小根堆 heap 来存储每个组的最右的端点，由于是小根堆，所以 heap.top() 对应的是最小的右端点。

因为要分成尽可能少的组，等效于把尽可能多的区间塞进同一组。

1. 将所有区间按左端点从小到大排序
2. 从前往后处理每个区间，判断能否将其放到某个现有的组中，实际上就是判断当前区间的左端点是否小于最大的右端点
   • 如果可以 range[i].l > heap ，则将其放进去，并更新当前组的最大右端点
   • 如果不可以，则开一个新的组，将其放进去 heap.push(range[i].r) .
3. heap 有多大，就有多少个组。

代码如下:

#include <iostream>
#include <algorithm>
#include <queue>
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 main()
{
    int n;
    cin >> n;
    for (int i = 0; i < n; i++) 
        cin >> Range[i].l >> Range[i].r;
    
    sort(Range, Range + n);
    
    //用一个小根堆来维护所有组的右端点
    priority_queue<int, vector<int>, greater<int>> heap; 
    for (int i = 0; i < n; i++){
        auto t = Range[i];
        if (heap.empty() || heap.top() >= t.l) //放不进去则新开一组
            heap.push(t.r);
        else {
            heap.pop();
            heap.push(t.r); //放进去并更新右端点
        }
    }
    
    cout << heap.size() << endl;
    
    return 0;
}

---

区间覆盖

原题链接：907. 区间覆盖 - AcWing题库

【题目描述】

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

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

【输入格式】

第一行包含两个整数 s 和 t，表示给定线段区间的两个端点。(-10⁹ <= s <= t <= 10⁹)

第二行包含整数 N，表示给定区间数。(1 <= N <= 10⁵)

接下来 N 行，每行包含两个整数 a_i, b_i，表示一个区间的两个端点。(-10⁹ <= a_i <= b_i <= 10⁹)

【输出格式】

输出一个整数，表示所需最少区间数。
如果无解，则输出 -1。

【输入样例】

1 5
3
-1 3
2 4
3 5

【输出样例】

2

思路：要求能覆盖目标区间的最少区间，那么所选区间就要尽可能的长，选取的数量才能尽可能少。

1. 将所有区间按照左端点从小到大排序
2. 从前往后依次枚举每个区间，在所有能够覆盖 L 的区间中，选择右端点最大的区间，然后将 L 更新成右端点的最大值。

代码如下：

#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 main()
{
    int n;
    int L, R;
    cin >> L >> R;
    cin >> n;
    
    for (int i = 0; i < n; i++) 
        cin >> Range[i].l >> Range[i].r;
    
    sort(Range, Range + n);
    
    int res = 0;
    bool f = false;
    for (int i = 0; i < n; ) //依次遍历每个区间
    {
        int j = i, r = -2e9; //j表示第几个区间
        
        //遍历所有左端点在L的左边的区间，选出右端点最大的
        while (j < n && Range[j].l <= L)
        {
            r = max(r, Range[j].r);
            j++;
        }
        
        if (r < L) //如果所有右端点都小于L，则无解
        {
            res = -1;
            break;
        }
        
        res++;
        if (r >= R) //循环出口
        {
            f = true;
            break;
        }
        
        //更新端点和遍历的区间
        L = r;
        i = j; 
    }
    
    if (!f) res = -1;
    cout << res << endl;
    
    return 0;
}

---