CF817F MEX Queries
题目描述
You are given a set of integer numbers, initially it is empty. You should perform nn queries.
There are three different types of queries:
- 1 ll rr — Add all missing numbers from the interval [l,r][l,r]
- 2 ll rr — Remove all present numbers from the interval [l,r][l,r]
- 3 ll rr — Invert the interval [l,r][l,r] — add all missing and remove all present numbers from the interval [l,r][l,r]
After each query you should output MEX of the set — the smallest positive (MEX >=1>=1 ) integer number which is not presented in the set.
输入格式
The first line contains one integer number nn ( 1<=n<=10^{5}1<=n<=105 ).
Next nn lines contain three integer numbers t,l,rt,l,r ( 1<=t<=3,1<=l<=r<=10^{18}1<=t<=3,1<=l<=r<=1018 ) — type of the query, left and right bounds.
输出格式
Print MEX of the set after each query.
题意翻译
-
维护一个集合，初始为空。
-
有
33
种操作：
- 把 [l,r][l,r] 中在集合中没有出现过的数添加到集合中。
- 把 [l,r][l,r] 中在集合中出现过的数从集合中删掉。
- 把 [l,r][l,r] 中在集合中没有出现过的数添加到集合中，并把 [l,r][l,r] 中在集合中出现过的数从集合中删掉。
-
每次操作后输出集合的 operatorname{MEX}MEX —— 在集合中没有出现过的最小正整数。
-
1le nle 10^51≤n≤105，1le lle rle 10^{18}1≤l≤r≤1018。
题解：
线段树+离散化。
但是并不是裸的叠加。
从头开始思考，展现一下思路过程：首先要维护三种操作，区间置零，区间置1，区间反转，并输出从左到右第一个0的位置。
区间操作必然考虑线段树，但是这个值域维护令人望而却步，但是这么大的值域需要离散化已经是套路的东西了。所以直接把其排序去重映射到一个有限值域中，在这个有限值域建线段树，最后返回的值再映射回去就好了。
然后思考如何维护这几种操作。区间赋值可以打lazy标记，区间反转同样可以打反转标记。打多重lazy标记的时候一定要考虑好标记间的相互影响，换言之，就是两种标记下传的先后问题。那么我们考虑：
区间赋值，之前的反转标记就会失效。区间反转，之前的赋值标记就会取反。它们之间没有先后的顺序，只是每次打新标记的时候直接重新赋值另一种标记就好。
至于求MEX值，很多大佬用了线段树+二分。但是没有必要，只需要先查左子树后查右子树，就可以找到最左的节点。有人说这是贪心，勉强算吧，小贪心？
之后是本题坑点：离散化要把r+1也离散进去。为什么呢？着重讲一讲：因为我们本来想维护值域，但是因为值域太宽广了，所以要离散化。但是并不是所有的都可以离散化。仔细思考：这道题，我们把([l,r])进行离散操作，这个([l,r])就有可能连成一起。那么假如我们要查询(l,r)中间的数，就查不到。这个时候就不能离散化。
但是为什么这道题可以用离散化呢？就是因为我们是整个区间赋值、反转，所以，可以保证答案肯定不会出现在这些区间内部，因为我们本来就是按块操作的。
但是(r+1)不一样，显然，(r+1)是有可能被算成答案的。所以(r+1)也要离散进去。
就大功告成了。
代码：
#include<cstdio>
#include<algorithm>
#define int long long
#define lson pos<<1
#define rson pos<<1|1
using namespace std;
char *p1,*p2,buf[100000];
#define nc() (p1==p2&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++)
int read()
{
int x=0,f=1;
char ch=nc();
while(ch<48||ch>57)
if(ch=='-')
f=-1,ch=nc();
while(ch>=48&&ch<=57)
x=x*10+ch-48,ch=nc();
return x*f;
}
const int maxn=1e5+5;
int n;
int opt[maxn],l[maxn],r[maxn];
int a[maxn<<2],cnt;
int sum[maxn<<4],lazy[maxn<<4],rev[maxn<<4];
//sum求和，lazy赋值，rev反转
void pushup(int pos)
{
sum[pos]=sum[lson]+sum[rson];
}
void build(int pos,int l,int r)
{
int mid=(l+r)>>1;
lazy[pos]=-1;
if(l==r)
return;
build(lson,l,mid);
build(rson,mid+1,r);
}
void mark(int pos,int l,int r,int k)
{
if(k==1)
{
sum[pos]=(r-l+1);
lazy[pos]=1;
rev[pos]=0;
}
else if(k==2)
{
lazy[pos]=0;
sum[pos]=0;
rev[pos]=0;
}
else
{
if(lazy[pos]!=-1)
lazy[pos]^=1;
else
rev[pos]^=1;
sum[pos]=(r-l+1)-sum[pos];
}
}
void pushdown(int pos,int l,int r)
{
int mid=(l+r)>>1;
if(lazy[pos]==1)
{
mark(lson,l,mid,1);
mark(rson,mid+1,r,1);
lazy[pos]=-1;
}
else if(lazy[pos]==0)
{
mark(lson,l,mid,2);
mark(rson,mid+1,r,2);
lazy[pos]=-1;
}
if(rev[pos])
{
mark(lson,l,mid,3);
mark(rson,mid+1,r,3);
rev[pos]=0;
}
}
void update(int pos,int l,int r,int x,int y,int k)
{
int mid=(l+r)>>1;
if(l==r)
{
if(k==1)
sum[pos]=1;
else if(k==2)
sum[pos]=0;
else
sum[pos]^=1;
return;
}
if(x<=l && r<=y)
{
mark(pos,l,r,k);
return;
}
pushdown(pos,l,r);
if(x<=mid)
update(lson,l,mid,x,y,k);
if(y>mid)
update(rson,mid+1,r,x,y,k);
pushup(pos);
}
int query(int pos,int l,int r)
{
int mid=(l+r)>>1;
if(l==r)
return l;
pushdown(pos,l,r);
if(sum[lson]<(mid-l+1))
return query(lson,l,mid);
else
return query(rson,mid+1,r);
}
signed main()
{
n=read();
a[++cnt]=1;
for(int i=1;i<=n;i++)
{
opt[i]=read();l[i]=read();r[i]=read();
a[++cnt]=l[i];a[++cnt]=r[i];a[++cnt]=r[i]+1;
}
sort(a+1,a+cnt+1);
cnt=unique(a+1,a+cnt+1)-(a+1);
build(1,1,cnt);
for(int i=1;i<=n;i++)
{
l[i]=lower_bound(a+1,a+cnt+1,l[i])-a;
r[i]=lower_bound(a+1,a+cnt+1,r[i])-a;
update(1,1,cnt,l[i],r[i],opt[i]);
printf("%lld
",a[query(1,1,cnt)]);
}
return 0;
}