bzoj3123 【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完成这些操作。

Input

第一行包含个正整数 testcase，表示 当前测试数据的测试点编号 。保证 1≤testcase ≤20 。

第二行包含 三个整数 N，M，T，分别表示节点数、 初始边数 、操作数 。

第三行包含 N个非负 整数表示 N个节点上的 权值。

接下来 M行，每行包含两个整数 x和 y，表示 初始的时候， 点 x和点 y之 间有一条无向边。

接下来 T行，每行描述一个操作，格式为“ Q x y k ”或者“L x y”，其含义见题目描述部分。

Output

对于每一个 第一类操作，输出一个非负整数表示答案。

Sample Input

1

8 4 8

1 1 2 2 3 3 4 4

4 7

1 8

2 4

2 1

Q 8 7 3

Q 3 5 1

Q 10 0 0

L 5 4

L 3 2

L 0 7

Q 9 2 5

Q 6 1 6

Sample Output

2

2

1

4

2

直接主席树，动态加边用启发式合并，和按秩合并有点像。。
lca初始化的时候把16打成6，，，RE了半天。

#include<cstdio>
#include<algorithm>
#include<cmath>
#include<cstring>
#define fo(i,a,b) for(int i=a;i<=b;i++)
#define fd(i,a,b) for(int i=a;i>=b;i--)
using namespace std;
int n,m;
const int N=2e5+6;
const int M=N*2;
const int inf=1e9;
struct node
{
    int l,r,s;
}t[N*100];
int root[N],q,dep[N],head[M],next[M],go[M],val[N],tot,cnt;
int size[N],fa[N][20],f[N];
inline void add(int x,int y)
{
    go[++cnt]=y;
    next[cnt]=head[x];
    head[x]=cnt;
}
inline int get(int x)
{
    if (f[x]==x)return x;
    else return f[x]=get(f[x]);
}
inline void ins(int &x,int y,int l,int r,int pos)
{
    x=++tot;
    t[x].s=t[y].s;
    if (l==r)
    {
        t[x].s++;
        return;
    }
    t[x].l=t[y].l;
    t[x].r=t[y].r;
    int mid=(l+r)/2;
    if (pos<=mid)ins(t[x].l,t[y].l,l,mid,pos);
    else ins(t[x].r,t[y].r,mid+1,r,pos);
    t[x].s=t[t[x].l].s+t[t[x].r].s;
}
inline void dfs(int x)
{
    fo(i,1,16)fa[x][i]=0;
    fo(i,1,16)fa[x][i]=fa[fa[x][i-1]][i-1];
    ins(root[x],root[fa[x][0]],0,inf,val[x]);
    int i=head[x];
    while (i)
    {
        int v=go[i];
        if (v!=fa[x][0])
        {
            dep[v]=dep[x]+1;
            fa[v][0]=x;
            dfs(v);
        }
        i=next[i];
    }
}
inline int getlca(int x,int y)
{
    if (dep[x]<dep[y])swap(x,y);
    fd(i,16,0)if (dep[fa[x][i]]>=dep[y])x=fa[x][i];
    if (x==y)return x;
    fd(i,16,0)
    if (fa[x][i]!=fa[y][i])
    {
        x=fa[x][i];
        y=fa[y][i];
    }
    return fa[x][0];
}
inline int solve(int r1,int r2,int r3,int r4,int l,int r,int k)
{
    if (l==r)return l;
    int mid=(l+r)/2;
    int s=t[t[r1].l].s+t[t[r2].l].s-t[t[r3].l].s-t[t[r4].l].s;
    if (s>=k)return solve(t[r1].l,t[r2].l,t[r3].l,t[r4].l,l,mid,k);
    else return solve(t[r1].r,t[r2].r,t[r3].r,t[r4].r,mid+1,r,k-s);
}
inline int query(int x,int y,int z)
{
    int lca=getlca(x,y);
    return solve(root[x],root[y],root[lca],root[fa[lca][0]],0,inf,z);
}
inline void link(int x,int y)
{
    add(x,y);
    add(y,x);
    int fx=get(x),fy=get(y);
    if (size[fx]<size[fy])
    {
        size[fy]+=size[fx];
        f[fx]=fy;
        fa[x][0]=y;
        dep[x]=dep[y]+1;
        dfs(x);
    }
    else
    {
        size[fx]+=size[fy];
        f[fy]=fx;
        fa[y][0]=x;
        dep[y]=dep[x]+1;
        dfs(y);
    }
}
int main()
{
    int cas;
    scanf("%d",&cas);
    tot=0,cnt=0;
        memset(head,0,sizeof(head));
        memset(f,0,sizeof(f));
        scanf("%d%d%d",&n,&m,&q);
        fo(i,1,n)
        {
            scanf("%d",&val[i]);
            size[i]=1,f[i]=i;
        }
        fo(i,1,m)
        {
            int x,y;
            scanf("%d%d",&x,&y);
            size[get(x)]+=size[get(y)];
            f[get(x)]=get(y);
            add(x,y);
            add(y,x);
        }
        fo(i,1,n)
        if (!fa[i][0])
        {
            dep[i]=1;
            dfs(i);
        }
        int last=0;
        fo(i,1,q)
        {
            char ch[1];
            scanf("%s",ch);
            if (ch[0]=='Q')
            {
                int x,y,z;
                scanf("%d%d%d",&x,&y,&z);
                x^=last,y^=last,z^=last;
                last=query(x,y,z);
                printf("%d\n",last);
            }
            else
            {
                int x,y;
                scanf("%d%d",&x,&y);
                x^=last,y^=last;
                link(x,y);
            }
        }
    return 0;
}