[BZOJ2758] [SCOI2012]Blinker的噩梦 扫描线+set

题目大意：有n个圆或凸多边形，这些图形不会相交，每当走入或走出一个图形时需要异或上一个代价，有m组操作：

询问操作，每次询问从一个点走到另一个点时，需要的代价（初始代价为0）

修改操作，每次修改一个图形的代价

数据范围：n≤1e5，点权的绝对值不大于1e9

此题真实毒瘤题

考虑到此题图形之间两两互不相交，那么图形与图形之间的关系为相离或包含，包含关系我们可以将其建成一棵树结构。

我们用set来维护一个以x为第一关键字的扫描线，每次扫描到一个新的图形，我们就将该图形拆成上下两部分（可以理解为左右括号），分别加入到set中（考虑到图形不会包含，那么在图形出现的值域内，如果只考虑当前加入的这些图形，这些图形构成的括号序列是不会发生变化的，我们只需要写一个在给定X值情况下能求出图形上下两部分的Y值的函数即可）

然后再做一条射线往上，碰到了另一个多边形，不难发现只会有两种情况：

第一种情况：遇到一个图形的上部分，那么显然碰到的那个图形包含了当前图形。

第二种情况：遇到一个图形的下部分，那么显然当前图形与碰到的图形是相离关系。

当某个图形在扫描线变化后不再出现时，从set中删去这个图形。

（以上说得有点玄乎，感性理解下吧）

我们基于这些关系，建出了一棵树。

对于一个查询操作，显然是查询从树上一个点到另一个点的异或和，考虑到这个值可能会被修改，用树状数组随便维护下就好了

然后就没了，说起来很简单写起来hhh。

注意精度损失！！！！！

 #include<bits/stdc++.h>
 #define M 300005
 #define INF 1e15
 #define eps 1e-9
 #define D long double
 #define sqr(x) ((x)*(x))
 #define lowbit(x) ((x)&(-x))
 using namespace std; 

 int b[M]={},N,val[M]={};
 void updata(int x,int k){ for(int i=x;i<=N;i+=lowbit(i)) b[i]^=k;}
 int query(int x){ int k=; for(int i=x;i;i-=lowbit(i)) k^=b[i]; return k;}

 struct edge{int u,next;}e[M]={}; int head[M]={},use=;
 void add(int x,int y){use++;e[use].u=y;e[use].next=head[x];head[x]=use;}
 int dfn[M]={},low[M]={},fa[M]={},t=;
 void dfs(int x){
     dfn[x]=++t;
     for(int i=head[x];i;i=e[i].next) dfs(e[i].u);
     low[x]=t;
     updata(dfn[x],val[x]);
     updata(low[x]+,val[x]);
 }

 D nowX;

 struct node{
     int n,down,val,id;
     D X,Y,r,x[],y[];
     D lx,rx;
     void makebig(){X=Y=; r=INF;lx=-INF; rx=INF;}
     void rd(int ID){
         id=ID;
         char op[]; scanf("%s",op);
         if(op[]=='C'){
             n=; scanf("%Lf%Lf%Lf",&X,&Y,&r);
             lx=X-r; rx=X+r;
         }else{
             scanf("%d",&n);
             lx=INF; rx=-INF;
             for(int i=;i<=n;i++){
                 scanf("%Lf%Lf",x+i,y+i);
                 lx=min(lx,x[i]);
                 rx=max(rx,x[i]);
             }
             x[n+]=x[]; y[n+]=y[];
         }
         scanf("%d",&val);
     }
     void rd(){
         n=-;
         scanf("%Lf%Lf",&X,&Y);
         lx=rx=X;
     }
     D get(D now){
         D Y1=INF,Y2=-INF;
         if(n==-) return Y;
         if(n==){
             Y1=Y-sqrt(max(sqr(r)-sqr(X-now),(D)0.0));
             Y2=Y+sqrt(max(sqr(r)-sqr(X-now),(D)0.0));
         }else{
             for(int i=;i<=n;i++){
                 D now1=x[i],now2=x[i+];
                 if(now1==now2) continue;
                 if(now1>now2) swap(now1,now2);
                 if(!(now1-eps<=now&&now<=now2+eps)) continue;
                 D k=(y[i+]-y[i])/(x[i+]-x[i]);
                 D nowy=y[i]+(now-x[i])*k;
                 Y1=min(Y1,nowy);
                 Y2=max(Y2,nowy);
             }
         }
         if(down) return Y1;
         return Y2;
     }
     friend bool operator <(node a,node b){
         D vala=a.get(nowX);
         D valb=b.get(nowX);
         if(fabs(vala-valb)>eps) return vala<valb;
         return a.down>b.down;
     }
 }a[M];
 set<node> s;
 int n,m,q; 

 void pushset(node now){
     now.down=; s.insert(now);
     now.down=; s.insert(now);
 }
 void popset(node now){
     now.down=; s.erase(now);
     now.down=; s.erase(now);
 }

 struct hh{
     int id,zf; hh(int ID=,int ZF=){id=ID; zf=ZF;}
     friend bool operator <(hh x,hh y){
         D valx,valy;
         if(x.zf==-) valx=a[x.id].lx; else valx=a[x.id].rx;
         if(y.zf==-) valy=a[y.id].lx; else valy=a[y.id].rx;
         return valx<valy;
     }
 }p[M*]={};

 int pointsum=;
 int chx[M]={},chval[M]={},id1[M]={},id2[M]={};

 int main(){
 //    freopen("in.txt","r",stdin);
 //    freopen("out.txt","w",stdout);
     a[].makebig(); fa[]=-;
     nowX=-INF; pushset(a[]);
     scanf("%d%d",&n,&q);
     for(int i=;i<=n;i++) a[++pointsum].rd(i);

     for(int i=;i<=n;i++) val[i]=a[i].val;
     for(int i=;i<=n;i++) p[++m]=hh(i,),p[++m]=hh(i,-);

     for(int i=;i<=q;i++){
         char op[]; scanf("%s",op);
         if(op[]=='C'){scanf("%d%d",chx+i,chval+i);}
         else{
             a[++pointsum].rd();
             p[++m]=hh(pointsum,);
             id1[i]=pointsum;

             a[++pointsum].rd();
             p[++m]=hh(pointsum,);
             id2[i]=pointsum;
         }
     }

     sort(p+,p+m+);
     N=m+;
     for(int x=;x<=m;x++){
         int id=p[x].id;
         //cout<<s.size()<<endl;
         if(p[x].zf==-) nowX=a[id].lx; else nowX=a[id].rx;
         if(p[x].zf==-||p[x].zf==){
             pushset(a[id]);
             set<node>::iterator it=s.find(a[id]); it++;
             if(it->down)
             fa[id]=fa[it->id];
             else fa[id]=it->id;

             if(p[x].zf==)
             popset(a[id]);
         }else{
             popset(a[id]);
         }
     }
     for(int i=;i<=m;i++) add(fa[i],i);
     dfs();
     int ans=;
     for(int i=;i<=q;i++){
     //    if(chx[i]) continue;
         if(chx[i]){
             int x=chx[i],zhi=chval[i];
             updata(dfn[x],val[x]);
             updata(low[x]+,val[x]);
             val[x]=zhi;
             updata(dfn[x],val[x]);
             updata(low[x]+,val[x]);
         }else{
             int ans1=query(dfn[id1[i]]);
             int ans2=query(dfn[id2[i]]);
             ans=ans^ans1^ans2;
             printf("%d\n",ans);
         }
     }
 //    return 0;
 }