[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]={0},N,val[M]={0}; 
void updata(int x,int k){ for(int i=x;i<=N;i+=lowbit(i)) b[i]^=k;}
int query(int x){ int k=0; for(int i=x;i;i-=lowbit(i)) k^=b[i]; return k;}

struct edge{int u,next;}e[M]={0}; int head[M]={0},use=0;
void add(int x,int y){use++;e[use].u=y;e[use].next=head[x];head[x]=use;}
int dfn[M]={0},low[M]={0},fa[M]={0},t=0;
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]+1,val[x]);
}

D nowX;

struct node{
    int n,down,val,id; 
    D X,Y,r,x[37],y[37];
    D lx,rx;
    void makebig(){X=Y=0; r=INF;lx=-INF; rx=INF;}
    void rd(int ID){
        id=ID;
        char op[10]; scanf("%s",op);
        if(op[0]=='C'){
            n=0; scanf("%Lf%Lf%Lf",&X,&Y,&r);
            lx=X-r; rx=X+r;
        }else{
            scanf("%d",&n);
            lx=INF; rx=-INF;
            for(int i=1;i<=n;i++){
                scanf("%Lf%Lf",x+i,y+i);
                lx=min(lx,x[i]);
                rx=max(rx,x[i]);
            }
            x[n+1]=x[1]; y[n+1]=y[1];
        }
        scanf("%d",&val);
    }
    void rd(){
        n=-1;
        scanf("%Lf%Lf",&X,&Y);
        lx=rx=X;
    }
    D get(D now){
        D Y1=INF,Y2=-INF;
        if(n==-1) return Y;
        if(n==0){
            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=1;i<=n;i++){
                D now1=x[i],now2=x[i+1];
                if(now1==now2) continue;
                if(now1>now2) swap(now1,now2);
                if(!(now1-eps<=now&&now<=now2+eps)) continue;
                D k=(y[i+1]-y[i])/(x[i+1]-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=0; s.insert(now);
    now.down=1; s.insert(now);
}
void popset(node now){
    now.down=0; s.erase(now);
    now.down=1; s.erase(now);
}

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

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

int main(){
//    freopen("in.txt","r",stdin);
//    freopen("out.txt","w",stdout);
    a[0].makebig(); fa[0]=-1;
    nowX=-INF; pushset(a[0]);
    scanf("%d%d",&n,&q);
    for(int i=1;i<=n;i++) a[++pointsum].rd(i);
    
    for(int i=1;i<=n;i++) val[i]=a[i].val;
    for(int i=1;i<=n;i++) p[++m]=hh(i,1),p[++m]=hh(i,-1);
    
    for(int i=1;i<=q;i++){
        char op[10]; scanf("%s",op);
        if(op[0]=='C'){scanf("%d%d",chx+i,chval+i);}
        else{
            a[++pointsum].rd();
            p[++m]=hh(pointsum,0);
            id1[i]=pointsum;
            
            a[++pointsum].rd();
            p[++m]=hh(pointsum,0);
            id2[i]=pointsum;
        }
    }
    
    sort(p+1,p+m+1);
    N=m+1;
    for(int x=1;x<=m;x++){
        int id=p[x].id;
        //cout<<s.size()<<endl;
        if(p[x].zf==-1) nowX=a[id].lx; else nowX=a[id].rx;
        if(p[x].zf==-1||p[x].zf==0){
            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==0) 
            popset(a[id]);
        }else{
            popset(a[id]);
        }
    }
    for(int i=1;i<=m;i++) add(fa[i],i);
    dfs(0);
    int ans=0; 
    for(int i=1;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]+1,val[x]);
            val[x]=zhi;
            updata(dfn[x],val[x]);
            updata(low[x]+1,val[x]);
        }else{
            int ans1=query(dfn[id1[i]]);
            int ans2=query(dfn[id2[i]]);
            ans=ans^ans1^ans2;
            printf("%d
",ans);
        }
    }
//    return 0;
}