题解 P4688 [Ynoi2016]掉进兔子洞

这是我的第一道 Ynoi，同时也一发卡到了最优解，发篇题解纪念一下 qwq，不开 $O_2$ 也是能过的。

本题需要的知识点：

- 分块，莫队
- $ ext{bitset}$ 优化
- 离散化
- 其它的奇技淫巧

首先明确这题要求的，三个区间内不同时出现的数的个数。列出柿子就是 $(r_1 - l_1 + 1) + (r_2 - l_2 + 1) + (r_3 - l_3 + 1) - rep$，其中 $rep$ 是三个区间内同时出现的数的个数。

首先 $1 le a_i le 10^9$，显然离散化。同时注意，本题离散化时不能去重，即不需要 $ ext{unique}$，直接使用 $ ext{lower} ext{_bound}$ 即可。

随后对每个询问求删除的数，对于这种对多个区间内元素个数的维护我们不难想到莫队，如莫队板子题 小 Z 的袜子 就是这种题型。

老套路，将长度为 $n$ 的序列拆成 $sqrt n$ 块，把所有询问的区间以 $l$ 为第一关键字，$r$ 为第二关键字排序。

此时考虑如何求出上文的 $rep$。对每个询问开一个长度为 $n$ 的 $ ext{bitset}$，每一位是否为 $1$ 即表示这一位是否被删除。再维护另一个 $ ext{bitset}$ $Bst$，每一位是否为 $1$ 表示这一区间是否有这个数。则最后要删除的数就是三个区间的 $Bst$ 取交集。

最后要注意，

- 此题 $1 le n, m le 10^5$，开不下这么大的 $ ext{bitset}$，需要分几次求答案。

- 区间移动位置时，要先加再减。如果先减，则可能会让 $cnt$ 变成负数再变成正数，会导致 $ ext{bitset}$ 无效访问内存，从而导致 RE。

于是这题就结束了，$ ext{Code}$：

#include <iostream>
#include <cstdio>
#include <bitset>
#include <cstring>
#include <cmath>
#include <algorithm>
#define il inline
#define rg register

//namespace IO {
//    const int SIZE = (1 << 20) + 1;
//    char ibuf[SIZE], *iS, *iT, obuf[SIZE],*oS = obuf, *oT = obuf + SIZE - 1;
//    char _st[55];
//    int _qr = 0;
//    inline char gc() {
//        return (iS == iT ? iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin), (iS == iT ? EOF : *iS++) : *iS++);
//    }
//    inline void qread() {}
//    template<class T1, class ...T2>
//    inline void qread(T1 &IEE, T2&... ls) {
//        register T1 __ = 0, ___ = 1;
//        register char ch;
//        while(!isdigit(ch = gc())) ___ = (ch == '-') ? -___ : ___;
//        do {
//            __ = (__ << 1) + (__ << 3) + (ch ^ 48);
//        }while(isdigit(ch = gc()));
//        __ *= ___;
//        IEE = __;
//        qread(ls...);
//        return ;
//    }
//    inline void flush() {
//        fwrite(obuf, 1, oS - obuf, stdout);
//        oS = obuf;
//        return ;
//    }
//    inline void putc_(char _x) {
//        *oS++ = _x;
//        if(oS == oT) flush();
//    }
//    inline void qwrite() {}
//    template<class T1, class ...T2>
//    inline void qwrite(T1 IEE, T2... ls) {
//        if(!IEE) putc_('0');
//        if(IEE < 0) putc_('-'), IEE = -IEE;
//        while(IEE) _st[++_qr] = IEE % 10 + '0', IEE /= 10;
//        while(_qr) putc_(_st[_qr--]);
//        qwrite(ls...);
//        return ;
//    }
//    struct Flusher_{~Flusher_(){flush();}}io_flusher;
//}
//
//using namespace IO;
//此部分是快读，为防止抄袭注释掉了。
//注 : 此快读板子是@SPFA(uid=177999) 给我的，为防止他被说是 ctj 特来此声明一下。
using namespace std;

const int N = 1e5 + 5;
const int M = 25005;

bitset<N> bst[M], Bst;//bitset 开 25000，分四次求出答案。
bool vis[M];
int n, m, tot, blocksize;
int a[N], b[N], blocknum[N];
int ans[N], cnt[N];

struct Node {
    int id, l, r;
    bool operator < (const Node &oth) const {
        return blocknum[l] == blocknum[oth.l] ? r < oth.r : blocknum[l] < blocknum[oth.l];
    }
} Que[N << 2];

il void Add(int id) {
    int x = a[id];
    ++cnt[x];
    Bst[x + cnt[x] - 1] = 1;     
}

il void Del(int id) {
    int x = a[id];
    --cnt[x];
    Bst[x + cnt[x]] = 0;
}

il void Solve(int k) {
    tot = 0;
    memset(vis, false, sizeof vis);
    memset(ans, 0, sizeof ans);
    memset(cnt, 0, sizeof cnt);
    //因为是分次求出答案，不要忘记每次初始化。
    for(rg int i = 1; i <= k; i++) {
        for(int j = 1; j <= 3; j++) {
            Que[++tot].id = i;
            qread(Que[tot].l, Que[tot].r);
            ans[i] += Que[tot].r - Que[tot].l + 1;
        }
    }
    sort(Que + 1, Que + tot + 1);
    Bst.reset();
    int l = 1, r = 0;
    for(rg int i = 1; i <= tot; i++) {
        while(l > Que[i].l) Add(--l);
        while(r < Que[i].r) Add(++r);
        while(l < Que[i].l) Del(l++);
        while(r > Que[i].r) Del(r--);
          //区间移动位置先加再减。
        if(!vis[Que[i].id]) bst[Que[i].id] = Bst, vis[Que[i].id] = true;//此区间未访问过，直接赋值
        else bst[Que[i].id] &= Bst;//访问过，取交集
    }
    for(rg int i = 1; i <= k; i++) ans[i] -= bst[i].count() * 3;
    for(rg int i = 1; i <= k; i++) printf("%d
", ans[i]);
}

int main() {
    qread(n, m);
    blocksize = sqrt(n);
    for(rg int i = 1; i <= n; i++) {
        qread(a[i]);
        b[i] = a[i];
        blocknum[i] = (i - 1) / blocksize + 1;
    }
    sort(b + 1, b + n + 1);
    for(rg int i = 1; i <= n; i++) a[i] = lower_bound(b + 1, b + n + 1, a[i]) - b;//离散化，不需要去重
    int T = M - 5;
    while(m) {
        if(m < T) {
            Solve(m);
            break;
        }
        else Solve(T), m -= T;
    }//分次求出答案
    return 0;
}