Codeforces983D. Arkady and Rectangles

$n \leq 100000$个矩形，一个一个覆盖在坐标系上，每个颜色都不一样，问最后能看到几种颜色。

由于后面的颜色可以覆盖前面的颜色，可以把颜色与时间联系上，第$i$个矩形颜色$i$来把时间维变成Max，接下来就是二维操作。

把矩形差分后按$x$排序可以得到一个y轴上的区间操作：区间加上或删除某种颜色；查区间内没统计过答案的最大的颜色（以此保证每个颜色只统计一次）。

区间维护：啪在了这整个区间的所有颜色（集合s，用set存）；最大的没统计过答案的颜色（Max值）。一个区间中s的最大值如果比孩子的Max还要大，那么要么他会成为这个区间的Max，要么这个区间里没有Max（把孩子区间里的Max啪没了）。这里注意的是每个区间只有覆盖这整个区间的颜色，没有包括他儿子的，所以会出现儿子有些颜色比父亲大的情况。如果他成为了这个区间的Max，首先他得没统计过答案，其次他得看得见，也就是不会被孩子里的所有比他大的颜色给啪没。注意他虽然是啪在这整个区间的颜色的最大值，但可能被若干子区间的比他大的颜色一起啪没，所以如果他要能露个头出来，必须大于子区间的Min--区间可见颜色中最小的一个。如果s的最大值比孩子的Max小，直接继承。每次把同个x的所有操作搞完之后，不停地取线段树根节点的Max并把这段颜色重新加入（标记了统计过答案，效果不同）。

现在多了个Min，Min只需要看s的最大值会不会把左右孩子的Min给啪掉，如果会就是s的最大值，否则直接继承。

俩log。

 #include<stdio.h>
 #include<string.h>
 #include<stdlib.h>
 #include<set>
 #include<algorithm>
 //#include<math.h>
 //#include<iostream>
 //#include<time.h>
 using namespace std;

 #define LL long long
 int qread()
 {
     char c; int s=,t=; while ((c=getchar())<'' || c>'') (c=='-') && (t=-);
     do s=s*+c-''; while ((c=getchar())>='' && c<=''); return s*t;
 }

 //Pay attention to read!

 int n,m;
 #define maxn 400011
 int lisax[maxn],lx=,lisay[maxn],ly=,ll[maxn],rr[maxn];
 struct MM{int x,y1,y2,ty,col;}mm[maxn]; int lm=;
 bool cmpx(const MM &a,const MM &b) {return a.x<b.x;}

 bool vis[maxn];
 struct SMT
 {
     struct Node{int ls,rs,Max,Min; set<int,greater<int> > s;}a[maxn<<];
     int size,n;
     void up(int x)
     {
         Node &b=a[x],&p=a[a[x].ls],&q=a[a[x].rs];
         int mm=b.s.empty()?-:*(b.s.begin());
         if (mm>max(p.Max,q.Max))
         {
             if (vis[mm]) b.Max=-;
             else if (mm<min(p.Min,q.Min)) b.Max=-;
             else b.Max=mm;
         }
         else b.Max=max(p.Max,q.Max);
         b.Min=max(mm,min(p.Min,q.Min));
     }
     void build(int &x,int L,int R)
     {
         x=++size; a[x].Max=-; a[x].Min=-;
         if (L==R) return;
         int mid=(L+R)>>;
         build(a[x].ls,L,mid); build(a[x].rs,mid+,R);
     }
     void clear(int N) {size=; n=N; a[].Max=a[].Min=-; int x; build(x,,n);}
     int ql,qr,v;
     void Add(int x,int L,int R)
     {
         if (ql<=L && R<=qr) {if (!vis[v]) a[x].s.insert(v); up(x); return;}
         int mid=(L+R)>>;
         if (ql<=mid) Add(a[x].ls,L,mid);
         if (qr> mid) Add(a[x].rs,mid+,R);
         up(x);
     }
     void add(int L,int R,int V) {ql=L; qr=R; v=V; Add(,,n);}
     void DEL(int x,int L,int R)
     {
         if (ql<=L && R<=qr) {a[x].s.erase(v); up(x); return;}
         int mid=(L+R)>>;
         if (ql<=mid) DEL(a[x].ls,L,mid);
         if (qr> mid) DEL(a[x].rs,mid+,R);
         up(x);
     }
     void Del(int L,int R,int V) {ql=L; qr=R; v=V; DEL(,,n);}
 }t;

 int main()
 {
     m=qread();
     for (int i=,x1,x2;i<=m;i++)
     {
         x1=qread(); lm++; mm[lm].y1=qread(); x2=qread(); mm[lm].y2=qread();
         mm[lm].x=x1; mm[lm].ty=; mm[lm+]=mm[lm]; lm++; mm[lm].x=x2; mm[lm].ty=-;
         lisax[++lx]=x1; lisax[++lx]=x2; lisay[++ly]=mm[lm].y1; lisay[++ly]=mm[lm].y2;
         mm[lm].col=mm[lm-].col=i;
     }

     sort(lisax+,lisax++lx); sort(lisay+,lisay++ly);
     lx=unique(lisax+,lisax++lx)-lisax-; ly=unique(lisay+,lisay++ly)-lisay-;
     for (int i=;i<=lm;i++) mm[i].x=lower_bound(lisax+,lisax++lx,mm[i].x)-lisax,
     mm[i].y1=lower_bound(lisay+,lisay++ly,mm[i].y1)-lisay,
     mm[i].y2=lower_bound(lisay+,lisay++ly,mm[i].y2)-lisay;
     for (int i=;i<=m;i++) ll[i]=mm[i<<].y1,rr[i]=mm[i<<].y2;

     t.clear(ly);
     sort(mm+,mm++lm,cmpx);
     int ans=;
     for (int i=,j=;i<=lx;i++)
     {
         for (;j<=lm && mm[j].x==i;j++)
         {
             if (mm[j].ty==) t.add(mm[j].y1,mm[j].y2-,mm[j].col);
             else t.Del(mm[j].y1,mm[j].y2-,mm[j].col);
         }
         int tmp=t.a[].Max;
         while (~tmp)
         {
             vis[tmp]=; ans++; t.add(ll[tmp],rr[tmp]-,tmp);
             tmp=t.a[].Max;
         }
     }
     printf("%d\n",ans+);
     return ;
 }