「LibreOJ NOIP Round #1」七曜圣贤

题目啰嗦：
支持三个操作：

不可重复集合：
1.加入一个数

2.删除一个数

3.恢复目前最早的一次删除的数

操作可能不合法，每次有效操作之后求集合的mex（最小没有出现过的数）

50组数据+1e6，必须O(N)

维护删除、恢复的数的操作可以队列维护。

数有没有在集合里可以全局bool数组记录

加入删除一个数，mex怎么维护？

考虑化简问题：
只插入？

直接mex往上走到第一个没有出现的数即可。单增，O(N)

有删除？

如果删除小的一个数，mex要跳下来，然后再恢复这个删除的数，mex又得一步一步走上去。

能不能不跳？

可以！

只要知道当前删除的数最小的一个，和mex取min即可。

维护删除的数的集合：

插入一个数，删除一个数，维护最小的数。怎么看也得带logn

但是，发现恢复数是按照时间顺序从小到大

所以一个数如果比后面的数大，那么直到这个删除的数被恢复也不可能成为最小值。

单调队列维护。

#include<bits/stdc++.h>
#define reg register int
#define il inline
#define numb (ch^'0')
using namespace std;
typedef long long ll;
il void rd(int &x){
    char ch;x=;bool fl=false;
    while(!isdigit(ch=getchar()))(ch=='-')&&(fl=true);
    for(x=numb;isdigit(ch=getchar());x=x*+numb);
    (fl==true)&&(x=-x);
}
namespace Miracle{
const int N=1e6+;
const int mod=;
int ans[N];
int q[*N],l,r;
queue<int>que;
int p[N];
bool on[*N],has[*N];
namespace IO{
    int c;
    unsigned int seed;
    unsigned int randnum(){
        seed^=seed<<;
        seed^=seed>>;
        seed^=seed<<;
        return seed;
    }

    inline int read(int &x){scanf("%d",&x);return x;}
    inline void init_case(int &m,int &a,int &b,int &d,int p[]){
        scanf("%d%u%d%d%d%d",&m,&seed,&a,&b,&c,&d);
        for(int i=;i<=m;i++){
            if(randnum()%c==)p[i]=-;
            else p[i]=randnum()%b;
        }
    }

    inline void update_ans(unsigned int &ans_sum,unsigned int cur_ans,int no){
        const static unsigned int mod=;
        ans_sum^=(long long)no*(no+)%mod*cur_ans%mod;
    }
}
using IO::read;
using IO::init_case;
using IO::update_ans;
void clear(){
    memset(on,,sizeof on);
    memset(q,,sizeof q);
    l=,r=;
    memset(has,,sizeof has);
    while(!que.empty()) que.pop();
}
int get(){
    while(l<=r&&on[q[l]]) ++l;
    if(l<=r) return q[l];
    return 0x3f3f3f3f;
}
void upda(int c){
    while(l<=r&&q[r]>=c) --r;
    q[++r]=c;
}
int main(){
    int T;read(T);
    int m,a,b,d;
    while(T--){
        clear();
        init_case(m,a,b,d,p);

        for(reg i=;i<=a;++i) on[i]=,has[i]=;
        int mex=a+;
        for(reg i=;i<=m;++i){
            int k;
            if(p[i]==-){//case 3
                if(que.empty()||d){
                    ans[i]=;goto end;
                }else{
                    k=que.front();que.pop();
                    on[k]=;
                }
            }else{
                if(!on[p[i]]&&!has[p[i]]){
                    has[p[i]]=;
                    on[p[i]]=;
                }else if(on[p[i]]){
                    if(d==){
                        ans[i]=;goto end;
                    }else{
                        que.push(p[i]);
                        on[p[i]]=;
                        upda(p[i]);
                    }
                }else{
                    if(que.empty()||d){
                        ans[i]=;goto end;
                    }else{
                        k=que.front();que.pop();
                        on[k]=;
                    }
                }
            }
            while(on[mex]) ++mex;
            ans[i]=min(mex,get());
            end:;
        }
        ll op=;
        for(reg i=;i<=m;++i){
            op^=(ll)ans[i]*((ll)i*i%mod+*i%mod)%mod;
        }
        printf("%lld\n",op);
    }
    return ;
}
}
signed main(){
    Miracle::main();
    return ;
}

/*
   Author: *Miracle*
   Date: 2018/12/31 16:28:17
*/