bzoj 4939: [Ynoi2016]掉进兔子洞 莫队算法+bitset

题意

有 m 个询问，每次询问三个区间，把三个区间中同时出现的数一个一个删掉，问最后三个区间剩下的数的个数和，询问独立。注意这里删掉指的是一个一个删，不是把等于这个值的数直接删完，比如三个区间是 [1,2,2,3,3,3,3] , [1,2,2,3,3,3,3] 与 [1,1,2,3,3]，就一起扔掉了 1 个 1，1 个 2，2 个 3。
n , m <= 100000 , 1 <= a[i] <= 1000000000

分析

退役有个好处就是可以只做自己喜欢做的题。
这题显然要求的就是区间长度和-每个数在三个区间中出现次数的最小值的和*3，问题在于后者怎么求。
我们可以先把权值离散化，注意不要去重，那么每种权值就对应了一段区间，然后一个区间对应的bitset就是把某种权值在其对应区间内从前往后放。
比如输入的数是1 5 5 3 3，离散化之后就是1 4 4 3 3，那么区间[2,3]对应的bitset就是00011，区间[3,4]对应的bitset就是01010。
这样把每个区间的bitset&起来后1的个数就是我们要求的东西。
用莫队来求每个区间的bitset即可。

代码

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#include<bitset>
#include<cmath>

const int N=100005;
const int T=25000;

int n,m,a[N],bel[N],t[N],w[N],ans[T+5],tot,B;
bool flag[T+5];
struct data{int l,r,id;}p[T*3+5];
std::bitset<N> now,bit[T+5];

int read()
{
    int x=0,f=1;char ch=getchar();
    while (ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while (ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}

bool cmp(data a,data b)
{
    return bel[a.l]<bel[b.l]||bel[a.l]==bel[b.l]&&((bel[a.l]&1)?(a.r<b.r):(a.r>b.r));
}

void updata(int x,int op)
{
    int val=a[x];
    if (op==1) t[val]++,now[val+t[val]-1]=1;
    else now[val+t[val]-1]=0,t[val]--;
}

void solve(int m)
{
    tot=0;
    for (int i=1;i<=m;i++)
    {
        flag[i]=0;ans[i]=0;
        for (int j=1;j<=3;j++)
        {
            tot++;p[tot].id=i;
            p[tot].l=read();p[tot].r=read();
            ans[i]+=p[tot].r-p[tot].l+1;
        }
    }
    std::sort(p+1,p+tot+1,cmp);
    now.reset();
    memset(t,0,sizeof(t));
    for (int l=1,r=0,i=1;i<=tot;i++)
    {
        for (;r<p[i].r;r++) updata(r+1,1);
        for (;l>p[i].l;l--) updata(l-1,1);
        for (;r>p[i].r;r--) updata(r,-1);
        for (;l<p[i].l;l++) updata(l,-1);
        if (!flag[p[i].id]) bit[p[i].id]=now,flag[p[i].id]=1;
        else bit[p[i].id]&=now;
    }
    for (int i=1;i<=m;i++) printf("%d\n",ans[i]-bit[i].count()*3);
}

int main()
{
    n=read();m=read();B=sqrt(n);
    for (int i=1;i<=n;i++) a[i]=read(),w[i]=a[i];
    std::sort(w+1,w+n+1);
    for (int i=1;i<=n;i++) a[i]=std::lower_bound(w+1,w+n+1,a[i])-w;
    for (int i=1;i<=n;i++) bel[i]=(i+B-1)/B;
    while (m)
    {
        if (m<T) solve(m),m=0;
        else solve(T),m-=T;
    }
    return 0;
}