NC22593 签到题

题目链接

题目

题目描述

恭喜你找到了本场比赛的签到题！
为了让大家都有抽奖的机会，只需要复制粘贴以下代码（并且稍微填下空）即可 AC：
（我超良心的）

#include <algorithm>
 #include <iostream>
 #include <cstring>
 #include <climits>
 #include <cstdio>
 #include <vector>
 #include <cstdlib>
 #include <ctime>
 #include <cmath>
 #include <queue>
 #include <stack>
 #include <map>
 #include <set>
 #define fi first
 #define lc (x<<1)
 #define se second
 #define U unsigned
 #define rc (x<<1|1)
 #define Re register
 #define LL long long
 #define MP std::make_pair
 #define CLR(i,a) memset(i,a,sizeof(i))
 #define FOR(i,a,b) for(Re int i = a;i <= b;++i)
 #define ROF(i,a,b) for(Re int i = a;i >= b;--i)
 #define SFOR(i,a,b,c) for(Re int i = a;i <= b;i+=c)
 #define SROF(i,a,b,c) for(Re int i = a;i >= b;i-=c)
 #define DEBUG(x) std::cerr << #x << '=' << x << std::endl
 const int MAXN = 1000000+5;
 int N,maxL;
 std::set<std::pair<int,int> > L;
 inline int calc(){
     // 返回 set 中所有线段的并长度。(每个 pair 表示一个线段[first,second]
 }
 int main(){
     scanf("%d%d",&N,&maxL);
     while(N--){
         int opt,x,y;
         scanf("%d%d%d",&opt,&x,&y);
         if(opt == 1){
             if(L.find(MP(x,y)) != L.end()) continue;
             L.insert(MP(x,y));
         }
         if(opt == 2){
             if(L.find(MP(x,y)) == L.end()) continue;
             L.erase(MP(x,y));
         }
         if(opt == 3){
             printf("%d\n",calc());
         }
     }
     return 0;
 }

输入描述

第一行两个整数 N,L，意义如代码所述。

接下来 N 行，每行三个整数 opt,l,r，意义如代码所述。

输出描述

对于每一组 opt=3 的询问输出一个答案。

示例1

输入

6 13
1 1 2
1 4 5
1 4 7
1 6 9
1 12 13
3 3 3

输出

10

说明

我们依次加入线段 $[1,2],[4,5],[4,7],[6,9],[12,13]$ ， 它们的并集长度为 10.

备注

$N \leq 10^5,L \leq 10^5 ,0 \leq l \leq r \leq L$ ，保证数据随机生成。

题解

方法一

知识点：线段树，扫描线。

长度并问题，可以用扫描线的区间覆盖线段树解决。

需要注意的是，题目的长度是区间点的个数，为了便于区间覆盖线段树实现，可以先将每个点映射为一个区间，因此可以有映射 0(1,2),1(2,3),...,L(L+1,L+2) ，表示用区间 $[1,2],[2,3],\cdots ,[L+1,L+2]$ 表示点 $0,1,\cdots,L$ 。

设 $dot$ 为映射后的端点集，即 $\{ 1,2, \cdots ,L+2 \}$ 。注意，线段树维护的是 $dot$ 点构成的区间，例如 $1$ 号区间对应 $dot$ 的 $[1,2]$ ，即原题的点 $0$ 代表的区间。

区间信息需要维护编号左右端点 $l,r$ 、被完整覆盖次数 $cnt$ 、区间覆盖长度 $len$ 。分三类讨论：

1. 区间被完整覆盖，则 $len$ 为整个区间实际长度。
2. 否则，若区间是一个点，则覆盖长度为 $0$ 。
3. 否则， $len$ 由子区间转移。

push_up 函数为：

void push_up(int rt) {
    if (node[rt].cnt) node[rt].len = dot[node[rt].r + 1] - dot[node[rt].l];
    else if (node[rt].l == node[rt].r) node[rt].len = 0;
    else node[rt].len = node[rt << 1].len + node[rt << 1 | 1].len;
}

区间修改需要维护新增线段个数 $cnt$ 。显然，对相应区间的完整覆盖次数加上 $cnt$ ，然后用向上转移函数更新答案即可。区间修改函数为：

node[rt].cnt += cnt, push_up(rt);

可以发现，线段树区间的长度 $r-l+1$ 等于实际长度 $dot_{r+1} - dot_{l}$ 等于原题 $[l,r]$ 表示的长度。因此实际上， $dot$ 集合在这道题里是不需要显示存储的，可以直接用线段树区间长度计算。

注意，若点间距是不等的，那么 $dot$ 集合是必须的，通常需要离散化后，方便线段树实现。这里，其实为了展示扫描线所使用的线段树，就没有直接用线段树区间长度代替实际长度计算。

时间复杂度 $O((n+L) \log L)$

空间复杂度 $O(L)$

方法二

知识点：线段树。

这道题同样也可以通过记录一个区间没有被覆盖到的单位区间个数，从而计算一整个区间被覆盖到的区间长度。

区间信息需要维护长度 $len$ 、最小覆盖数 $cover$ 、最小覆盖的单位区间个数 $cnt$ 。 push_up 函数为：

friend T operator+(const T &a, const T &b) {
    int len = a.len + b.len;
    int cover = min(a.cover, b.cover);
    int cnt = (a.cover == cover ? a.cnt : 0) + (b.cover == cover ? b.cnt : 0);
    return {
        len,
        cover,
        cnt,
    };
}

区间修改需要维护新增线段个数 $add$ 。显然只需要对 $cover$ 加 $add$ 即可。区间修改函数为：

T operator()(const T &x) {
    return{
        x.len,
        x.cover + add,
      	x.cnt
    };
}

区间修改有结合律，可以设置懒标记。 push_down 函数（此题只询问 $[1,n]$ ，所以可以不写这个函数）：

F operator()(const F &g) { return { g.add + add }; }

时间复杂度 $O((n+L) \log L)$

空间复杂度 $O(L)$

代码

方法一

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
 
template<class T>
class Scanline {
    struct Segment {
        int l;
        int r;
        int cnt;
        T len;
    };
 
    int n;
    vector<T> dot;
    vector<Segment> node;
 
    void push_up(int rt) {
        if (node[rt].cnt) node[rt].len = dot[node[rt].r + 1] - dot[node[rt].l];
        else if (node[rt].l == node[rt].r) node[rt].len = 0;
        else node[rt].len = node[rt << 1].len + node[rt << 1 | 1].len;
    }
 
    void update(int rt, int l, int r, int x, int y, int cnt) {
        if (r < x || y < l) return;
        if (x <= l && r <= y) return node[rt].cnt += cnt, push_up(rt);
        int mid = l + r >> 1;
        update(rt << 1, l, mid, x, y, cnt);
        update(rt << 1 | 1, mid + 1, r, x, y, cnt);
        push_up(rt);
    }
 
public:
    Scanline() {}
    Scanline(const vector<T> &_dot) { init(_dot); }
    void init(const vector<T> &_dot) {
        assert(_dot.size() - 1 >= 1);
        n = _dot.size() - 2;
        dot = _dot;
        node.assign(n << 2, { 0,0,0,0 });
        function<void(int, int, int)> build = [&](int rt, int l, int r) {
            node[rt] = { l,r,0,0 };
            if (l == r) return;
            int mid = l + r >> 1;
            build(rt << 1, l, mid);
            build(rt << 1 | 1, mid + 1, r);
        };
        build(1, 1, n);
    }
 
    void update(int x, int y, int cnt) { update(1, 1, n, x, y, cnt); }
 
    Segment query() { return node[1]; }
};
 
int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n, L;
    cin >> n >> L;
    vector<int> dot(L + 3); //* 0(1,2),1(2,3),...,L(L+1,L+2)
    iota(dot.begin(), dot.end(), 0);
    Scanline<int> sl(dot);//* 线段长度，端点集
    set<pair<int, int>> st;
    for (int i = 1;i <= n;i++) {
        int op, l, r;
        cin >> op >> l >> r;
        l++, r++;
        if (op == 1) {
            if (st.find({ l, r }) != st.end())
                continue;
            st.insert({ l, r });
            sl.update(l, r, { 1 });
        }
        if (op == 2) {
            if (st.find({ l, r }) == st.end())
                continue;
            st.erase({ l,r });
            sl.update(l, r, { -1 });
        }
        if (op == 3) {
            cout << sl.query().len << '\n';
        }
    }
    return 0;
}

方法二

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
 
struct T {
    int len; //区间长度
    int cover; //最小覆盖数
    int cnt; //最小覆盖的单位区间个数
    static T e() { return { 0,(int)2e9,0 }; }
    friend T operator+(const T &a, const T &b) {
        int len = a.len + b.len;
        int cover = min(a.cover, b.cover);
        int cnt = (a.cover == cover ? a.cnt : 0) + (b.cover == cover ? b.cnt : 0);
        return {
            len,
            cover,
            cnt,
        };
    }
};
struct F {
    int add;
    static F e() { return { 0 }; }
    T operator()(const T &x) {
        return{
            x.len,
            x.cover + add,
            x.cnt
        };
    }
    F operator()(const F &g) { return { g.add + add }; }
};
template<class T, class F>
class SegmentTreeLazy {
    int n;
    vector<T> node;
    vector<F> lazy;
 
    void push_down(int rt) {
        node[rt << 1] = lazy[rt](node[rt << 1]);
        lazy[rt << 1] = lazy[rt](lazy[rt << 1]);
        node[rt << 1 | 1] = lazy[rt](node[rt << 1 | 1]);
        lazy[rt << 1 | 1] = lazy[rt](lazy[rt << 1 | 1]);
        lazy[rt] = F::e();
    }
 
    void update(int rt, int l, int r, int x, int y, F f) {
        if (r < x || y < l) return;
        if (x <= l && r <= y) return node[rt] = f(node[rt]), lazy[rt] = f(lazy[rt]), void();
        push_down(rt);
        int mid = l + r >> 1;
        update(rt << 1, l, mid, x, y, f);
        update(rt << 1 | 1, mid + 1, r, x, y, f);
        node[rt] = node[rt << 1] + node[rt << 1 | 1];
    }
 
    T query(int rt, int l, int r, int x, int y) {
        if (r < x || y < l) return T::e();
        if (x <= l && r <= y) return node[rt];
        push_down(rt);
        int mid = l + r >> 1;
        return query(rt << 1, l, mid, x, y) + query(rt << 1 | 1, mid + 1, r, x, y);
    }
 
public:
    SegmentTreeLazy(int _n = 0) { init(_n); }
    SegmentTreeLazy(int _n, const vector<T> &src) { init(_n, src); }
 
    void init(int _n) {
        n = _n;
        node.assign(n << 2, T::e());
        lazy.assign(n << 2, F::e());
    }
    void init(int _n, const vector<T> &src) {
        init(_n);
        function<void(int, int, int)> build = [&](int rt, int l, int r) {
            if (l == r) return node[rt] = src[l], void();
            int mid = l + r >> 1;
            build(rt << 1, l, mid);
            build(rt << 1 | 1, mid + 1, r);
            node[rt] = node[rt << 1] + node[rt << 1 | 1];
        };
        build(1, 1, n);
    }
 
    void update(int x, int y, F f) { update(1, 1, n, x, y, f); }
 
    T query(int x, int y) { return query(1, 1, n, x, y); }
};
 
int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n, L;
    cin >> n >> L;
    SegmentTreeLazy<T, F> sgt(L + 1, vector<T>(L + 2, { 1,0,1 }));
    set<pair<int, int>> st;
    for (int i = 1;i <= n;i++) {
        int op, l, r;
        cin >> op >> l >> r;
        l++, r++;
        if (op == 1) {
            if (st.find({ l, r }) != st.end())
                continue;
            st.insert({ l, r });
            sgt.update(l, r, { 1 });
        }
        if (op == 2) {
            if (st.find({ l, r }) == st.end())
                continue;
            st.erase({ l,r });
            sgt.update(l, r, { -1 });
        }
        if (op == 3) {
            auto [len, cover, cnt] = sgt.query(1, L + 1);
            cout << (cover ? len : len - cnt) << '\n';
        }
    }
    return 0;
}