【SDOI2013】森林

Description

小 Z有一片 森林 ，含有 N个节点， 每个 节点上都有一非负 整数作为 权值 。 初始的时候， 森林中有 M条边。
小 Z希望 执行 T个操作 ，操作有两类：
1、Q x y k 查询 点 x到点 y路径上 所有的 权值 中， 第 k小的权值是多少。 此 操作保证点 x和点 y连通，同时这两个节点的路径上至少有 k个点。
2、L x y 在点 x和点 y之间连接一条边。保证完成此操作后， 仍然是一片森 林。
为了体现程序的在线性，我们把输入数据进行加密。 设 lastans 为程序上 一次输出的结果，初始的时候 lastans 为 0。
对于一个 输入的 操作 Q x y k ，其真实操作为 Q x^lastans y^lastans k^lastans。
对于一个输入的操作 L x y，其真实操作为 L x^lastans y^lastans。
其中 ^运算符表示 异或，等价于 pascal中的 xor 运算符。
请写一个程序来 帮助小 Z完成这些操作。

Solution

一看到就是用主席树来搞了，很快就打出来了，有点不同的只是有个合并而已。

空间爆炸啊！

怎么只有80分！
其实发现打法中有许多的空间浪费，但是这样很难去节约，怎么办？

启发式合并

把小数合并到大树中，这样空间损耗小了，时间损耗也小了。
不知道为什么总是改不对。
后来竟然改成了链表来打。才发现原来插入的方式不符合启发式合并。

Code

#include
#include
#include
#include
#include
#define fo(i,a,b) for(i=a;i<=b;i++)
#define fod(i,a,b) for(i=a;i>=b;i--)
#define rep(i,a) for(i=first[a];i;i=next[i])
using namespace std;
const int maxn=80007;
int i,j,k,l,n,m,ans,tcase;
int first[maxn*2],next[maxn*2],last[maxn*2],num,x,y,p,o;
int f[maxn][17],deep[maxn],a[maxn],tot,da,son[maxn],fa[maxn];
bool bz[maxn];
char ch;
struct node{
    node *ls,*rs;
    int size;
    void init(){
        ls=rs=NULL;
        size=0;
    }
    node(){
        init();
    }
    void change(int v,int l,int r,node* copy){
        int mid=(l+r)/2;
        size+=(copy ? copy->size : 0);
        size++;
        if (l==r) return;
        if(v<=mid){
            rs=(copy?copy->rs:NULL);
            if(!ls)ls=new node;
            ls->change(v,l,mid,copy?copy->ls:NULL);
        }
        else{
            ls=(copy?copy->ls:NULL);
            if(!rs)rs=new node;
            rs->change(v,mid+1,r,copy?copy->rs:NULL);
        }
    }
}t[maxn];
int gf(int x){
    if(!fa[x])return x;
    fa[x]=gf(fa[x]);
    return fa[x];
}
void add(int x,int y){
    last[++tot]=y;
    next[tot]=first[x];
    first[x]=tot;
    last[++tot]=x;
    next[tot]=first[y];
    first[y]=tot;
}
void dfs(int x,int y){
    int i,j;
    f[x][0]=y;deep[x]=deep[y]+1;
    bz[x]=1;
    fo(j,1,16){
        f[x][j]=f[f[x][j-1]][j-1];
    }
    t[x].init();
    t[x].change(a[x],1,da,&t[y]);
    rep(i,x){
        if(last[i]!=y)dfs(last[i],x);
    }
}
void dfs1(int x,int y){
    int i,j;
    f[x][0]=y;deep[x]=deep[y]+1;
    bz[x]=1;fa[x]=gf(y);son[gf(y)]+=1;
    fo(j,1,16){
        f[x][j]=f[f[x][j-1]][j-1];
    }
    t[x].init();
    t[x].change(a[x],1,da,&t[y]);
    rep(i,x){
        if(last[i]!=y)dfs(last[i],x);
    }
}
int lca(int x,int y){
    int i,j,k;
    if(deep[x]y])swap(x,y);
    fod(i,16,0)if(deep[f[x][i]]>deep[y])x=f[x][i];    
    if(deep[x]!=deep[y])x=f[x][0];
    fod(i,16,0)if(f[x][i]!=f[y][i])x=f[x][i],y=f[y][i];
    if(x!=y)return f[x][0];else return x;
}
int find(node *x,node *y,node *z,node *u,int l ,int r,int k){
    int mid=(l+r)/2,o=0;
    if(l==r)return l;
    if(x&&x->ls)o+=x->ls->size;
    if(y&&y->ls)o+=y->ls->size;
    if(z&&z->ls)o-=z->ls->size;
    if(u&&u->ls)o-=u->ls->size;
    if(o>=k)return find(x?x->ls:NULL,y?y->ls:NULL,z?z->ls:NULL,u?u->ls:NULL,l,mid,k);
    else return find(x?x->rs:NULL,y?y->rs:NULL,z?z->rs:NULL,u?u->rs:NULL,mid+1,r,k-o);
}
void merge(int x,int y){
    int w=gf(x),e=gf(y);
    add(x,y);
    if(w!=e){
        if(son[w]x,y);
        }
        else{
            fa[e]=w;
            son[w]+=son[e];
            dfs(y,x);
        }
    }
}
int main(){
//  freopen("fan.in","r",stdin);
//  freopen("fan.out","w",stdout);
    for(scanf("%d",&tcase);tcase;tcase=0){
        scanf("%d%d%d",&n,&m,&k);
        da=1000000000;
        fo(i,1,n){
            scanf("%d",&a[i]);
            son[i]=1;
            t[i].change(a[i],1,da,NULL);
        }
        fo(i,1,m){
            scanf("%d%d",&x,&y);
            merge(x,y);
        }
        ans=0;
        fo(i,1,k){
            scanf("%s",&ch);
            if(ch=='Q'){
                scanf("%d%d%d",&x,&y,&p);x^=ans,y^=ans,p^=ans;
                o=lca(x,y);
                ans=find(&t[x],&t[y],f[o][0]?&t[f[o][0]]:NULL,&t[o],1,da,p);
                printf("%d\n",ans);
            }
            else{
                scanf("%d%d",&x,&y);x^=ans,y^=ans;
                merge(x,y);
            }
        }
    }
}