Range Set Insertion Query (区间合并 + 差分)

Range Set Insertion Query(区间合并 + 差分)

一、题目描述

有 N 个集合 S1, S2, ..., SN,初始全为空。

进行 Q 次操作,第 i 次操作给定 (Li, Ri, Xi),表示把 Xi 加到 S[Li], S[Li+1], ..., S[Ri] 中。

求所有操作结束后,每个集合 Si 的元素个数。

对应题目:AtCoder ABC

二、思路分析

暴力做法

每次操作对区间 [Li, Ri] 内的所有集合添加一个元素,复杂度 O(Q × N),会超时。

关键观察

题目要求的是每个集合最终有多少个元素,而不是具体有哪些元素。

也就是说,如果某个值 Xi 被添加到了某个区间,那么这个区间内每个集合的元素个数都会 +1,不管 Xi 具体是什么。

核心转化

对于每个不同的值 X:

  1. 收集所有 X 相同的操作区间
  2. 把这些区间合并(有重叠或相邻的合并成一个)
  3. 合并后的每个区间,对答案的贡献就是整体 +1

最后用差分数组统计每个位置被多少个不同的值覆盖过,就是答案。

为什么合并区间

如果两个操作 (L1, R1, X) 和 (L2, R2, X) 的值相同,那么它们对答案的贡献可以合并:

  • 如果区间有重叠或相邻,合并成一个更大的区间
  • 因为同一个值 X 对一个集合最多贡献 1 个元素(集合元素不重复)

所以合并后,每个合并区间只需要在差分数组上做一次 +1。

三、算法流程

  1. 读入所有操作,按 X 为第一关键字排序
  2. 遍历排序后的操作,对每个 X 相同的连续段做区间合并
  3. 合并后的区间在差分数组上 cf[L]++, cf[R+1]--
  4. 对差分数组做前缀和,得到每个集合的元素个数
  5. 输出

四、AC 代码

#include<bits/stdc++.h>
using namespace std;

const int N = 2e5 + 5;
const int Q = 2e5 + 5;

struct qj
{
    int L, R, x;
    bool operator<(const qj & w) const
    {
        if (x != w.x) return x < w.x;
        if (L != w.L) return L < w.L;
        return R < w.R;
    }
} arr[Q];

int cf[N];

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);

    int n, q;
    cin >> n >> q;

    for (int i = 1; i <= q; i++)
        cin >> arr[i].L >> arr[i].R >> arr[i].x;

    sort(arr + 1, arr + q + 1);

    // 区间合并
    vector<qj> res;
    res.push_back(arr[1]);
    int t = 0;

    for (int i = 2; i <= q; i++)
    {
        if (arr[i].x != res[t].x)
        {
            res.push_back(arr[i]);
            t++;
            continue;
        }
        if (arr[i].L <= res[t].R + 1 && arr[i].R >= res[t].R + 1)
            res[t].R = arr[i].R;
        else if (arr[i].L <= res[t].R + 1 && arr[i].R <= res[t].R)
            continue;
        else if (arr[i].L > res[t].R + 1)
            res.push_back(arr[i]), t++;
    }

    // 差分
    for (int i = 0; i < res.size(); i++)
    {
        int L = res[i].L, R = res[i].R;
        cf[L]++;
        cf[R + 1]--;
    }

    // 前缀和输出
    int sum = 0;
    for (int i = 1; i <= n; i++)
    {
        sum += cf[i];
        if (i != 1) cout << ' ';
        cout << sum;
    }
    cout << endl;

    return 0;
}

五、代码说明

1. 排序

sort(arr + 1, arr + q + 1);

按 x 为第一关键字,L 为第二关键字,R 为第三关键字排序。

这样所有 x 相同的操作会连续排列在一起。

2. 区间合并

if (arr[i].x != res[t].x)
{
    res.push_back(arr[i]);
    t++;
    continue;
}
if (arr[i].L <= res[t].R + 1 && arr[i].R >= res[t].R + 1)
    res[t].R = arr[i].R;
else if (arr[i].L <= res[t].R + 1 && arr[i].R <= res[t].R)
    continue;
else if (arr[i].L > res[t].R + 1)
    res.push_back(arr[i]), t++;
  • 如果 x 不同,直接开新区间
  • 如果当前区间和上一个区间重叠或相邻(L <= R + 1),合并
  • 如果当前区间被上一个区间完全包含,跳过
  • 如果完全不重叠,开新区间

3. 差分

cf[L]++;
cf[R + 1]--;

对于每个合并后的区间 [L, R],在差分数组上标记。

4. 前缀和

int sum = 0;
for (int i = 1; i <= n; i++)
{
    sum += cf[i];
    cout << sum;
}

差分数组的前缀和就是每个位置被覆盖的次数,也就是集合元素个数。

六、复杂度

操作 时间复杂度
排序 O(Q log Q)
区间合并 O(Q)
差分 O(Q)
前缀和 O(N)
总复杂度 O(Q log Q + N)

N, Q ≤ 2 × 10^5,完全够用。

七、总结

要点 内容
核心转化 同一个值对一个集合最多贡献 1,所以相同值的区间可以合并
关键步骤 按 x 排序 → 区间合并 → 差分 → 前缀和
复杂度 O(Q log Q + N)
posted @ 2026-10-04 19:38  leaderling  阅读(33)  评论(0)    收藏  举报