【BZOJ3123】森林（主席树，启发式合并）

题意：一个带点权的森林，要求维护以下操作：

1.询问路径上的点权K大值

2.两点之间连边

n,m<=80000

思路：如果树的结构不发生变化只需要维护DFS序

现在因为树的结构发生变化，要将两棵树合并，这步可以用启发式合并，将比较小的树暴力连接到较大的树上面

离线的LCA算法无法维护，而倍增可以合并，所以用倍增求LCA

其余就是主席树，维护根到点的权值线段树就行了

机房里的罗爷爷写法比我高到不知道哪里去了

#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
const int M=200010;
int cas,n,m,q,i,x,y,k,edgenum,cnt,ans;
int a[M],b[M],c[M],head[M],vet[M],next[M],dep[M],fa[M][20],f[M],size[M],root[M];
struct node{int l,r,w;}tree[M*100];
bool cmp(int x,int y){return a[x]<a[y];}
int search(int x){
    if (f[x]!=x)f[x]=search(f[x]);
    return f[x];
}
void addedge(int x,int y){
    vet[++edgenum]=y;
    next[edgenum]=head[x];
    head[x]=edgenum;
}
void update(int x,int l,int r,int &p){
    tree[++cnt]=tree[p];p=cnt;tree[p].w++;
    if (l==r)return;
    int mid=l+r>>1;
    if (x<=mid)update(x,l,mid,tree[p].l);
        else update(x,mid+1,r,tree[p].r);
}
int query(int l,int r,int k,int x,int y,int z,int w){
    if (l==r)return l;
    int mid=l+r>>1,t=tree[tree[x].l].w+tree[tree[y].l].w-tree[tree[z].l].w-tree[tree[w].l].w;
    if (t>=k)return query(l,mid,k,tree[x].l,tree[y].l,tree[z].l,tree[w].l);
        else return query(mid+1,r,k-t,tree[x].r,tree[y].r,tree[z].r,tree[w].r);
}
int lca(int x,int y){
    if (dep[x]<dep[y])swap(x,y);
    int t=dep[x]-dep[y];
    for (int i=0;i<=16;i++)
        if (t&(1<<i))x=fa[x][i];
    for (int i=16;i>=0;i--)
        if (fa[x][i]!=fa[y][i])x=fa[x][i],y=fa[y][i];
    if (x==y)return x;
    return fa[x][0];
}
void dfs(int u,int pre){
    fa[u][0]=pre;
    for (int i=1;i<=16;i++)fa[u][i]=fa[fa[u][i-1]][i-1];
    root[u]=root[pre];
    update(c[u],1,n,root[u]);
    for (int e=head[u];e;e=next[e]){
        int v=vet[e];
        if (v==pre)continue;
        dep[v]=dep[u]+1;
        dfs(v,u);
    }
}
void link(int x,int y){
    int p=search(x),q=search(y);
    if (size[p]>size[q]){swap(x,y);swap(p,q);}
    dep[x]=dep[y]+1;
    dfs(x,y);
    f[p]=q;size[q]+=size[p];
    addedge(x,y);
    addedge(y,x);
}
int main(){
    scanf("%d",&cas);
    scanf("%d%d%d",&n,&m,&q);
    for (i=1;i<=n;i++)scanf("%d",&a[i]),b[i]=i;
    sort(b+1,b+n+1,cmp);
    for (i=1;i<=n;i++)c[b[i]]=i;
    for (i=1;i<=n;i++)f[i]=i,size[i]=1;
    cnt=n;
    for (i=1;i<=n;i++)root[i]=i,update(c[i],1,n,root[i]);
    for (i=1;i<=m;i++){
        scanf("%d%d",&x,&y);
        link(x,y);
    }
    while (q--){
        char s[10];
        scanf("%s",s);
        if (s[0]=='L'){
            scanf("%d%d",&x,&y);
            x^=ans;y^=ans;
            link(x,y);
        }else{
            scanf("%d%d%d",&x,&y,&k);
            x^=ans;y^=ans;k^=ans;
            int z=lca(x,y);
            printf("%d\n",ans=a[b[query(1,n,k,root[x],root[y],root[z],root[fa[z][0]])]]);
        }
    }
}

这是我的萎靡写法

var t:array[0..22000000]of record
                           l,r,s:longint;
                          end;
    f:array[0..300000,0..20]of longint;
    root,head,c,a,hash,h,dep,stk,size:array[0..500000]of longint;
    vet,next:array[0..610000]of longint;
    n,m,x,y,z,lastans,i,j,tot,cnt,k,s,up,top,que:longint;
    ch:string;

procedure swap(var x,y:longint);
var t:longint;
begin
 t:=x; x:=y; y:=t;
end;

procedure qsort(l,r:longint);
var i,j,mid:longint;
begin
 i:=l; j:=r; mid:=c[(l+r)>>1];
 repeat
  while mid>c[i] do inc(i);
  while mid<c[j] do dec(j);
  if i<=j then
  begin
   swap(c[i],c[j]);
   inc(i); dec(j);
  end;
 until i>j;
 if l<j then qsort(l,j);
 if i<r then qsort(i,r);
end;

function lsh(x:longint):longint;
var l,r,mid:longint;
begin
 l:=1; r:=up;
 while l<=r do
 begin
  mid:=(l+r)>>1;
  if x=hash[mid] then exit(mid);
  if x<hash[mid] then r:=mid-1
   else l:=mid+1;
 end;
end;

function find(k:longint):longint;
begin
 if h[k]<>k then h[k]:=find(h[k]);
 exit(h[k]);
end;

procedure add(a,b:longint);
begin
 inc(tot);
 next[tot]:=head[a];
 vet[tot]:=b;
 head[a]:=tot;
end;

procedure pushup(p:longint);
begin
 t[p].s:=t[t[p].l].s+t[t[p].r].s;
end;

procedure update(l,r,x:longint;var y:longint;v:longint);
var mid:longint;
begin
 inc(cnt); y:=cnt;
 t[y]:=t[x]; inc(t[y].s);
 if l=r then exit;
 mid:=(l+r)>>1;
 if v<=mid then update(l,mid,t[x].l,t[y].l,v)
  else update(mid+1,r,t[x].r,t[y].r,v);
 pushup(y);
end;

procedure dfs(u,pre:longint);
var e,v,x,y:longint;
begin
 update(1,up,root[pre],root[u],a[u]);
 e:=head[u];
 dep[u]:=dep[pre]+1;
 f[u,0]:=pre;
 while e<>0 do
 begin
  v:=vet[e];
  if v<>pre then
  begin
   dfs(v,u);
   x:=find(v); y:=find(u);
   if size[x]<size[y] then
   begin
    size[x]:=size[y]+size[x];
    h[y]:=x;
   end
    else begin size[y]:=size[x]+size[y]; h[x]:=y; end;
  end;
  e:=next[e];
 end;
end;

function lca(x,y:longint):longint;
var i,d:longint;
begin
 if dep[x]<dep[y] then swap(x,y);
 d:=dep[x]-dep[y];
 for i:=0 to 20 do
  if d and (1<<i)>0 then x:=f[x,i];
 for i:=20 downto 0 do
  if f[x,i]<>f[y,i] then
  begin
   x:=f[x,i]; y:=f[y,i];
  end;
 if x=y then exit(x);
 exit(f[x,0]);
end;

function query(l,r,x,y,z,w,k:longint):longint;
var mid,tmp:longint;
begin
 if l=r then exit(l);
 mid:=(l+r)>>1;
 tmp:=t[t[x].l].s+t[t[y].l].s-t[t[z].l].s-t[t[w].l].s;
 if tmp>=k then
 begin
  x:=t[x].l; y:=t[y].l; z:=t[z].l; w:=t[w].l;
  exit(query(l,mid,x,y,z,w,k));
 end
  else
  begin
   x:=t[x].r; y:=t[y].r; z:=t[z].r; w:=t[w].r;
   exit(query(mid+1,r,x,y,z,w,k-tmp));
  end;
end;

function ask(x,y,z:longint):longint;
var q:longint;
begin
 q:=lca(x,y);
 exit(hash[query(1,up,root[x],root[y],root[q],root[f[q,0]],z)]);
end;

procedure rebuild(u,pre:longint);
var e,v:longint;
begin
 inc(top); stk[top]:=u;
 update(1,up,root[pre],root[u],a[u]);
 dep[u]:=dep[pre]+1;
 f[u,0]:=pre;
 e:=head[u];
 while e<>0 do
 begin
  v:=vet[e];
  if v<>pre then rebuild(v,u);
  e:=next[e];
 end;
end;

procedure merge(x,y:longint);
var tx,ty,z,i,j:longint;
begin
 tx:=find(x); ty:=find(y);
 if size[tx]>size[ty] then
 begin
  swap(tx,ty); swap(x,y);
 end;
 top:=0;
 add(x,y); add(y,x);
 rebuild(x,y);
 h[tx]:=ty; size[ty]:=size[ty]+size[tx];
 for i:=1 to 20 do
  for j:=1 to top do
  begin
   z:=stk[j];
   f[z,i]:=f[f[z,i-1],i-1];
  end;
end;

begin
 assign(input,'bzoj3123.in'); reset(input);
 assign(output,'bzoj3123.out'); rewrite(output);
 readln(x);
 readln(n,m,que);
 for i:=1 to n do
 begin
  read(a[i]);
  c[i]:=a[i];
 end;
 qsort(1,n);
 up:=1; hash[1]:=c[1];
 for i:=2 to n do
  if c[i]<>c[i-1] then begin inc(up); hash[up]:=c[i]; end;
 for i:=1 to n do a[i]:=lsh(a[i]);
 for i:=1 to m do
 begin
  readln(x,y);
  add(x,y);
  add(y,x);
 end;
 for i:=1 to n do
 begin
  h[i]:=i; size[i]:=1;
 end;
 for i:=1 to n do
  if root[i]=0 then dfs(i,0);
 for i:=1 to 20 do
  for j:=1 to n do f[j,i]:=f[f[j,i-1],i-1];
 for i:=1 to que do
 begin
  readln(ch); s:=0; k:=length(ch); x:=0; y:=0; z:=0;
  for j:=2 to k do
  begin
   if ch[j]=' ' then begin if ch[j-1]<>' ' then inc(s); continue; end;
   if s=1 then x:=x*10+ord(ch[j])-ord('0');
   if s=2 then y:=y*10+ord(ch[j])-ord('0');
   if s=3 then z:=z*10+ord(ch[j])-ord('0');
  end;
  if ch[1]='Q' then
  begin
   x:=x xor lastans; y:=y xor lastans; z:=z xor lastans; //writeln(x,' ',y,' ',z);
   k:=ask(x,y,z);
   writeln(k);
   lastans:=k;
  end
   else
   begin
    x:=x xor lastans; y:=y xor lastans;// writeln(x,' ',y,' ',z);
    merge(x,y);
   end;

 end;
 close(input);
 close(output);
end.