BZOJ3123 SDOI2013 森林

3123: [Sdoi2013]森林

Time Limit: 20 Sec  Memory Limit: 512 MB

Description

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

HINT

对于第一个操作 Q 8 7 3，此时 lastans=0，所以真实操作为Q 8^0 7^0 3^0，也即Q 8 7 3。点8到点7的路径上一共有5个点，其权值为4 1 1 2 4。这些权值中，第三小的为 2，输出 2，lastans变为2。对于第二个操作 Q 3 5 1 ，此时lastans=2，所以真实操作为Q 3^2 5^2 1^2 ，也即Q 1 7 3。点1到点7的路径上一共有4个点，其权值为 1 1 2 4 。这些权值中，第三小的为2，输出2，lastans变为 2。之后的操作类似。

 

 　　正解显然是主席树。

　　对于链上的查询k小，套路是对于每一个点开到根的权值线段树，查询就是x+y-lca-fa[lca]；

　　相当于把链分成两条搞搞，可持久化水一水就好了。

　　所以如果没有操作2，就是 BZOJ2588 一模一样了。

　　对于操作2，因为没有撤销操作，所以可以

　　可以放心大胆的打暴力。

　　其实不叫暴力，叫启发式合并。

　　每次合并把点数少的扔进点数大的里面。

　　把这部分重新dfs、挂倍增、重建主席树就好了。

　　复杂度证明？抱歉我并不会。

　　好像是讲，合并后小的集合大小至少翻倍，所以不会超过log次？

　　每次操作不到O(n)，所以复杂度很可观，在O(nlogn)？

　　很有道理又很没道理啊。

　　然后一直RE，发现原因是主席树数组要往死里开。

　　因为每次合并都要重建，所以空间是O(nlog²n)的。

#include    <iostream>
#include    <cstdio>
#include    <cstdlib>
#include    <algorithm>
#include    <vector>
#include    <cstring>
#include    <queue>
#include    <complex>
#include    <stack>
#define LL long long int
#define dob double
using namespace std;

const int N = 100010;
struct Node{int to,next;}E[N*2];
struct Trie{int size,ls,rs;}T[N*101];
int n,m,w,bel[N],size[N],head[N],tot,tt;
int fa[21][N],dfn[N],tim,dep[N],root[N];
int val[N],lsh[N],cnt,Ans;

int gi()
{
  int x=0,res=1;char ch=getchar();
  while(ch>'9'||ch<'0'){if(ch=='-')res*=-1;ch=getchar();}
  while(ch<='9'&&ch>='0')x=x*10+ch-48,ch=getchar();
  return x*res;
}

inline int find(int x){
  if(bel[x]==x)return x;
  return bel[x]=find(bel[x]);
}

inline void link(int u,int v){
  E[++tt]=(Node){v,head[u]};
  head[u]=tt;
}

inline void build(int &x,int l,int r)
{
  x=++tot;if(l==r)return;
  int mid=(l+r)>>1;
  build(T[x].ls,l,mid);build(T[x].rs,mid+1,r);
}

inline void join(int x)
{
  for(int i=1;i<=19;++i)
    fa[i][x]=fa[i-1][fa[i-1][x]];
}

inline void Insert(int &rt,int last,int l,int r,int val)
{
  rt=++tot;T[rt]=T[last];T[rt].size++;
  if(l==r)return;
  int mid=(l+r)>>1;
  if(val<=mid)Insert(T[rt].ls,T[last].ls,l,mid,val);
  else Insert(T[rt].rs,T[last].rs,mid+1,r,val);
}

inline void dfs(int x,int fat){
  fa[0][x]=fat;join(x);dep[x]=dep[fat]+1;
  Insert(root[x],root[fat],1,cnt,val[x]);
  for(int e=head[x];e;e=E[e].next){
    int y=E[e].to;
    if(fa[0][x]==y)continue;
    dfs(y,x);
  }
}

inline int LCA(int x,int y)
{
  if(x==y)return x;
  if(dep[x]<dep[y])swap(x,y);
  for(int i=0,t=dep[x]-dep[y];(1<<i)<=t;++i)
    if((1<<i)&t)
      x=fa[i][x];
  if(x==y)return x;
  for(int i=19;i>=0;--i)
    if(fa[i][x]!=fa[i][y])
      x=fa[i][x],y=fa[i][y];
  return fa[0][x];
}

inline int query(int r1,int r2,int r3,int r4,int l,int r,int k)
{
  if(l==r)return l;
  int mid=(l+r)>>1;
  int sz=T[T[r1].ls].size+T[T[r2].ls].size-T[T[r3].ls].size-T[T[r4].ls].size;
  if(sz>=k)return query(T[r1].ls,T[r2].ls,T[r3].ls,T[r4].ls,l,mid,k);
  else return query(T[r1].rs,T[r2].rs,T[r3].rs,T[r4].rs,mid+1,r,k-sz);
}

int main()
{
  
  int Case=gi();
  tot=tt=root[0]=tim=0;
  n=gi();m=gi();w=gi();
  for(int i=1;i<=n;++i)
    lsh[i]=val[i]=gi(),bel[i]=i,size[i]=1;
  sort(lsh+1,lsh+n+1);
  cnt=unique(lsh+1,lsh+n+1)-lsh-1;
  for(int i=1;i<=n;++i)
    val[i]=lower_bound(lsh+1,lsh+cnt+1,val[i])-lsh;
  
  for(int i=1;i<=m;++i){
    int u=gi(),v=gi();
    int f1=find(u),f2=find(v);
    link(u,v);link(v,u);
    if(size[f1]<size[f2])swap(f1,f2);
    bel[f2]=f1;size[f1]+=size[f2];
  }
  //build(root[0],1,cnt);
  for(int i=1;i<=n;++i)
    if(!fa[0][i])dfs(i,0);
  
  while(w--){
    char type[11];
    scanf("%s",type+1);
    
    if(type[1]=='Q'){
      int x=gi()^Ans,y=gi()^Ans,k=gi()^Ans;
      int lca=LCA(x,y),flca=fa[0][lca];
      int f=query(root[x],root[y],root[lca],root[flca],1,cnt,k);
      printf("%d\n",Ans=lsh[f]);
    }
    
    if(type[1]=='L'){
      int x=gi()^Ans,y=gi()^Ans;
      int f1=find(x),f2=find(y);
      if(size[f1]<size[f2])swap(x,y),swap(f1,f2);
      bel[f2]=f1;size[f1]+=size[f2];
      fa[0][y]=x;dep[y]=dep[x]+1;
      dfs(y,x);
      link(x,y);link(y,x);
    }
    
  }
  /*fclose(stdin);
    fclose(stdout);*/
  return 0;
}