【AcWing】【C++】模板之区间和与区间合并

最近在对程序设计算法进行复习，终于复习完了AcWing基础算法课的第一章，在此对第一章最后两个模板区间和与区间合并进行记录与分享。

区间和

题目描述与输入输出样例

题目来自于AcWing 802. 区间和。

思路

从题目描述来说，第一眼看来这是一道前缀和的裸题，但是仔细查看题目会发现，题目描述中有提到“无限长的数轴”，并且索引$x$以及$l$和$r$的值可能为负，因此可能会出现如下情况，即区间范围非常的大，但是在这个非常大的区间当中，只存在两个位置有值，其它位置为全零，并且这两个位置相距非常远。

因此，想要解决这道题目，需要对题目中原始的下标索引进行离散化，这就引出了以下离散化的模板。

首先，使用pair<int, int>数据结构对两种类型的数据进行存储，分别是“在某个位置x加上c”以及“求区间[l, r]之间所有数的和”，分别使用类型为vector<pair<int, int> >的adds和query来存储。之后，再使用一个vector<int>类型的alls来存储所有出现过的下标。

然后，我们需要对下标进行排序，使用sort(alls.begin(), alls.end())来快速完成。排序之后，还需要对下标进行一次去重操作，使用alls.erase(unique(alls.begin(), alls.end()), alls.end())来快速完成。至此，便得到了离散化之后的数组下标索引，存储在alls当中。

现在，我们就可以对加法进行操作了，根据上文所描述，adds当中的元素存储了数轴上的相加操作，假设item是adds当中的元素，item.first存储的是离散化前原始下标对应的要执行加法的位置，而item.second存储的是要加的值。需要注意的是，我们需要使用的是离散化之后的下标，而离散化之后的下标被存储在alls当中，alls的下标就是离散化之后的下标，而下标位置的值存储的是离散化之前的索引。并且，alls当中的值是有序的，根据这一性质，我们可以在$O(n\log n)$内使用二分查找来寻找离散化之前索引在alls当中对应的下标，即离散化之后的下标。将这一二分查找的函数记作findf，使用findf(item.first)即可找到离散化之后要执行加法的位置的索引。

同理，查询操作的$l$和$r$也可以使用上述findf函数找到离散化后的下标。在执行查询操作之前，需要先对离散化后的数组求一遍前缀和，以在$O(1)$内执行查询区间和的操作。

完整代码如下：

#include <iostream>
#include <cstring>
#include <vector>
#include <algorithm>
using namespace std;

const int maxn = 3e5 + 5;
typedef pair<int, int> PII;

vector<PII> adds, query;
vector<int> alls;
int a[maxn] = {0}, s[maxn] = {0};

int n, m;

int findf(int x) {
    int l = 0, r = alls.size() - 1;
    while(l < r) {
        int mid = (l + r) >> 1;
        if(alls[mid] >= x)  r = mid;
        else                l = mid + 1;
    }
    return r + 1;
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cin >> n >> m;
    for(int i=1; i<=n; i++) {
        int x, c;
        cin >> x >> c;
        adds.push_back({x, c});
        alls.push_back(x);
    }
    for(int i=1; i<=m; i++) {
        int l, r;
        cin >> l >> r;
        query.push_back({l, r});
        alls.push_back(l);
        alls.push_back(r);
    }
    
    sort(alls.begin(), alls.end());
    alls.erase(unique(alls.begin(), alls.end()), alls.end());
    
    for(auto & item : adds) {
        int x = findf(item.first);
        a[x] += item.second;
    }
    for(int i=1; i<=alls.size(); i++) {
        s[i] = s[i-1] + a[i];
    }
    for(auto & item : query) {
        int l = findf(item.first), r = findf(item.second);
        cout << s[r] - s[l-1] << endl;
    }
    return 0;
}

区间合并

题目描述与输入输出样例

题目来自于AcWing 803. 区间合并。

这道题目相较于区间和来说简单了很多。

思路

这道题目有两种解法，一种是区间合并模板，一种是对左边界进行排序之后进行贪心。

区间合并模板

区间和并模板的思路非常清晰，同样使用vector<pair<int, int> >来对区间的端点进行存储。之后，直接开始执行区间合并操作。

首先初始化一个vector<pair<int, int> >类型的res作为区间合并的最终结果。声明左右边界l = -2e9, r = -2e9;作为区间端点。

之后，再对存储了输入区间的vector进行排序，按照左端点进行排序。

对存储了区间的vector进行遍历，假设range是其中的一段区间，range.first存储的是区间的左端点，range.second存储的是右端点。首先使用range.first与r进行比较，如果该区间的左端点比[l, r]区间的右端点还要大，说明range区间不能被合并到[l, r]区间当中，令l = range.first, r = range.second，代表对[l, r]区间进行更新。此时，如果l != -2e9，说明[l, r]区间还未被初始化，这时将这个新的区间加入到res当中。

而如果range区间的左端点比[l, r]区间的右端点小，说明这个区间可以被合并到[l, r]区间内，令r = max(r, range.second)，意味着如果range包含在[l, r]内，不需要对[l, r]的右端点进行更新，否则更新右端点。

最后，如果l != -2e9，则将当前的[l, r]区间加入到res当中，它的作用有两个，避免n = 0的特殊情况下将l = -2e9, r = -2e9加入到res当中，此外对于n = 1的情况，可以避免[l, r]没有被加入到res当中。

最后输出res的尺寸就是最终答案。

代码如下：

#include <algorithm>
#include <iostream>
#include <cstring>
#include <vector>
using namespace std;

typedef pair<int, int> PII;
vector<PII> segs;

int n;

void merge(vector<PII> & segs) {
    
    vector<PII> res;

    sort(segs.begin(), segs.end());

    int l = -2e9, r = -2e9;
    
    for(auto range : segs) {
        if(range.first > r) {
            if(l != -2e9)   res.push_back({l, r});
            l = range.first;
            r = range.second;
        }    
        else {
            r = max(r, range.second);
        }
    }
    if(l != -2e9)   res.push_back({l, r});
    segs = res;
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cin >> n;
    for(int i=1; i<=n; i++) {
        int l, r;
        cin >> l >> r;
        segs.push_back({l, r});
    }
    merge(segs);
    cout << segs.size();
    return 0;
}

贪心

贪心的思路其实更好理解，使用贪心不必对合并后的区间进行记录，而直接使用一个整型变量res来对答案进行记录即可，显然使用贪心可以AC这道题，但是不适合学习区间合并的模板以得到完整的合并区间。

贪心的代码如下：

#include <iostream>
#include <cstring>
#include <vector>
#include <algorithm>
using namespace std;

typedef pair<int, int> PII;
vector<PII> range;

int n;
int res = 0;

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cin >> n;
    for(int i=1; i<=n; i++) {
        int l, r;
        cin >> l >> r;
        range.push_back({l, r});
    }
    
    sort(range.begin(), range.end());
    
    int l = -2e9, r = -2e9;
    for(auto rg : range) {
        if(rg.first > r) {
            res ++ ;
            l = rg.first;
            r = rg.second;
        } else {
            r = max(r, rg.second);
        }
    }
    cout << res;
    return 0;
}