版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
click here~：https://www.luogu.org/problem/P3302
emmm这个题是真的烦 一看题发现这题不是count on a tree的升级版么
如果一点思路没有的话还是先做那个题比较好
这个题多了一个条件就是说，你在查询过程中需要连边，仔细一样脑海里并没有任何解题思路emmm，什么lct根本就不会
这道题其实是用了个启发式合并
何谓启发式合并呢，我看了别人的代码大概理解了一下：
题目上说了加边过后还是树结构，也就是说无论如何不会出现环什么奇怪的东西。
你肯定还是遵循求lca拿来这条链在主席树上搞个第k大
但是边更新了之后呢，你的lca或者倍增数组都发生了变化
所以这个时候你要重新构建倍增数组，重新暴力的更新主席树（其实也还真挺暴力）
因为树的边数就是固定的v-1,所以一开始边没有给全，你的树是分成一块一块的（一个联通块我们叫他小树）。
如果你加边，你需要吧这些小树块联合起来，最暴力的想法，我就拿其中一个小树连接到另一个小树的上边
就是一个是父节点，另一个就是子节点这样的dfs，就相当于把一个块加到另一个上边了。
其实就相当与重新吧某一块的点又遍历了一遍
但是如果仅仅是暴力的吧某个加到另一个上肯定会爆炸，所以启发式就是记录每一个块的个数，让小树中数量少的加到数量大的小树上边去，记录个数就用一个数组并查集来维护。
说白了：就是n个节点，m个块，你最后把他们连接成一颗完整的树，你每一次吧小的小树加到大的上，也就是在大的块上再次更新小块，自己琢磨琢磨，其实并没有多暴力~~挺优雅~
#include<stdio.h>
#include<string.h>
#include<iostream>
#include<algorithm>
#include<math.h>
#include<set>
#include<stack>
#include<vector>
#include<map>
#include<queue>
#define myself i,l,r
#define lson i<<1
#define rson i<<1|1
#define Lson i<<1,l,mid
#define Rson i<<1|1,mid+1,r
#define half (l+r)/2
#define inff 0x3f3f3f3f
#define lowbit(x) x&(-x)
#define PI 3.14159265358979323846
#define min4(a, b, c, d) min(min(a,b),min(c,d))
#define min3(x, y, z) min(min(x,y),min(y,z))
#define pii make_pair
#define pr pair<int,int>
const int dir[4][2] = {0, -1, -1, 0, 0, 1, 1, 0};
typedef long long ll;
const ll inFF = 9223372036854775807;
typedef unsigned long long ull;
using namespace std;
const int maxn=1e5+5;
int fa[maxn];
int f[maxn][17],d[maxn],son[maxn];
int a[maxn],b[maxn],len;
int head[maxn<<1],sign;
int root[maxn],t;
int vis[maxn];
struct node
{
int to,p;
}edge[maxn<<1];
struct nod
{
int l,r,cnt;
}tr[maxn*400];
int n,m,q,lastans;
char s[2];
int find(int x)
{
return (fa[x]==x)?x:fa[x]=find(fa[x]);
}
void add(int u,int v)
{
edge[sign]=node{v,head[u]};
head[u]=sign++;
}
int Hash(int x)
{
return lower_bound(b+1,b+1+len,x)-b;
}
void insert(int &now,int pre,int l,int r,int k)
{
now=++t;
tr[now]=tr[pre];
tr[now].cnt++;
if(l==r) return;
int mid=half;
if(k<=mid) insert(tr[now].l,tr[pre].l,l,mid,k);
else insert(tr[now].r,tr[pre].r,mid+1,r,k);
}
int query(int x1,int x2,int y1,int y2,int l,int r,int k)
{
int mid=half;
if(l==r) return b[l];
int x=tr[tr[y1].l].cnt+tr[tr[y2].l].cnt-tr[tr[x1].l].cnt-tr[tr[x2].l].cnt;
if(k<=x) return query(tr[x1].l,tr[x2].l,tr[y1].l,tr[y2].l,l,mid,k);
else return query(tr[x1].r,tr[x2].r,tr[y1].r,tr[y2].r,mid+1,r,k-x);
}
void dfs(int u,int pre,int rt)
{
f[u][0]=pre;
for(int i=1;(1<<i)<=n;i++)
f[u][i]=f[f[u][i-1]][i-1];
d[u]=d[pre]+1;
son[rt]++;
fa[u]=pre;
vis[u]=1;
insert(root[u],root[pre],1,len,Hash(a[u]));
for(int i=head[u];~i;i=edge[i].p)
{
int v=edge[i].to;
if(v!=pre) dfs(v,u,rt);
}
}
int get_lca(int x,int y)
{
if(d[x]<d[y]) swap(x,y);
int c=d[x]-d[y];
for(int i=0;(1<<i)<=c;i++)
if((1<<i)&c) x=f[x][i];
if(x!=y)
{
for(int i=(int)log2(n);i>=0;i--)
if(f[x][i]!=f[y][i]) x=f[x][i],y=f[y][i];
x=f[x][0];
}
return x;
}
void init()
{
for(int i=0;i<=n;i++) head[i]=-1;
sign=t=lastans=0;
}
int main()
{
int c,x,y,k;
cin>>c;
cin>>n>>m>>q;
init();
for(int i=1;i<=n;i++) scanf("%d",&a[i]),b[i]=a[i],fa[i]=i;
sort(b+1,b+1+n);
len=unique(b+1,b+1+n)-b-1;
for(int i=1;i<=m;i++)
scanf("%d %d",&x,&y),add(x,y),add(y,x);
for(int i=1;i<=n;i++)
{
if(!vis[i])
{
dfs(i,0,i);
fa[i]=i;
}
}
while(q--)
{
scanf("%s",s);
if(s[0]=='Q')
{
scanf("%d %d %d",&x,&y,&k);
x=x^lastans,y=y^lastans,k=k^lastans;
int lca=get_lca(x,y);
lastans=query(root[lca],root[f[lca][0]],root[x],root[y],1,len,k);
cout<<lastans<<endl;
}
else
{
scanf("%d %d",&x,&y);
x^=lastans,y^=lastans;
add(x,y),add(y,x);
int u=find(x),v=find(y);
if(son[u]<son[v])//把大树找出来，把小树重新暴力加到大树上，这里算是优雅的暴力
{
swap(u,v);
swap(x,y);
}
dfs(y,x,u);
}
}
return 0;
}