bzoj1146

这是一道无比繁琐的题目
话说这道题使我第一次练dfs序，比较感动；
首先dfs序就是在dfs过程中按照访问的顺序给每个点标上两个“时间戳”
一个是第一次访问到点i时的时间戳c[i]，一个是访问完以i为根时的时间戳cc[i]
根据c[i]，我们就可以将树变成序列，并且以i为根的子树，是序列上连续的一段
当进行单点修改时，我们可以用树状数组前缀和维护树上的点到根路径上所有点的修改情况和；
比如当点i修改时（比如+1） 则w[c[i]]+1,w[cc[i]]-1
然后这道题显然是要在dfs序上套带修改的主席树，根据bzoj2588的经验我们很好解决这个问题
由于修改的点要离散化，已经离线了，干脆用lca-tarjan求lca好了
由于空间卡的比较严，所以我们不能直接树状数组+主席树
而要先把原树建成主席树，然后修改的时候新建一棵主席树，用树状数组+主席树解决

 const maxn=;

 type node=record
        po,next:longint;
      end;
      link=record
        l,r,s:longint;
      end;
      point=record
        x,y,z:longint;
      end;
      qu=record
        num,loc,next:longint;
      end;

 var tree:array[..] of link;
     q:array[..] of point;
     w:array[..] of node;
     que:array[..] of qu;
     v:array[..] of boolean;
     e:array[..] of longint;
     g,fa,an,loc,d1,d2,ph,h,cc,c,b:array[..] of longint;
     st:array[..,..] of longint;
     sa,a:array[..] of longint;
     j,k,t,tot,num,len,x,y,z,i,p,s,n,m:longint;

 function lowbit(x:longint):longint;
   begin
     exit(x and (-x));
   end;

 procedure update(x:longint);
   begin
     tree[x].s:=tree[tree[x].l].s+tree[tree[x].r].s;
   end;

 procedure add(x,y:longint);
   begin
     inc(len);
     w[len].po:=y;
     w[len].next:=d1[x];
     d1[x]:=len;
   end;

 procedure addq(x,y,z:longint);
   begin
     inc(num);
     que[num].num:=y;
     que[num].loc:=z;
     que[num].next:=d2[x];
     d2[x]:=num;
   end;

 function find(x:longint):longint;
   var l,r,m:longint;
   begin
     l:=;
     r:=p;
     while l<=r do
     begin
       m:=(l+r) shr ;
       if sa[m]=x then exit(m);
       if sa[m]>x then r:=m- else l:=m+;
     end;
   end;

 function getf(x:longint):longint;
   begin
     if a[x]<>x then a[x]:=getf(a[x]);
     exit(a[x]);
   end;

 procedure dfs(x:longint);
   var i,y:longint;
   begin
     i:=d1[x];
     v[x]:=true;
     inc(tot);
     b[tot]:=x;  //b表示序列上的点对应的树上的哪个点
     c[x]:=tot;
     while i<> do
     begin
       y:=w[i].po;
       if not v[y] then
       begin
         fa[y]:=x;
         dfs(y);
         a[y]:=x;
       end;
       i:=w[i].next;
     end;
     cc[x]:=tot;
     i:=d2[x];
     while i<> do
     begin
       y:=que[i].num;
       if v[y] and (an[que[i].loc]=) then  //lca-tarjan
         an[que[i].loc]:=getf(y);
       i:=que[i].next;
     end;
   end;

 procedure sort(l,r: longint);
   var i,j,x,y: longint;
   begin
     i:=l;
     j:=r;
     x:=a[(l+r) div ];
     repeat
       while a[i]<x do inc(i);
       while x<a[j] do dec(j);
       if not(i>j) then
       begin
         y:=a[i];
         a[i]:=a[j];
         a[j]:=y;
         inc(i);
         j:=j-;
       end;
     until i>j;
     if l<j then sort(l,j);
     if i<r then sort(i,r);
   end;

 function build(l,r:longint):longint;
   var m,q:longint;
   begin
     inc(t);
     if l=r then exit(t)
     else begin
       q:=t;
       m:=(l+r) shr ;
       tree[q].l:=build(l,m);
       tree[q].r:=build(m+,r);
       exit(q);
     end;
   end;

 function insert(last,x,l,r,z:longint):longint;
   var m,q:longint;
   begin
     inc(t);
     if l=r then
     begin
       tree[t].s:=tree[last].s+z;
       exit(t);
     end
     else begin
       m:=(l+r) shr ;
       q:=t;
       if x<=m then
       begin
         tree[q].r:=tree[last].r;
         last:=tree[last].l;
         tree[q].l:=insert(last,x,l,m,z);
       end
       else begin
         tree[q].l:=tree[last].l;
         last:=tree[last].r;
         tree[q].r:=insert(last,x,m+,r,z);
       end;
       update(q);
       exit(q);
     end;
   end;

 procedure work(i,x,z:longint);
   begin
     while i<=n do  //树状数组+主席树
     begin
       h[i]:=insert(h[i],x,,p,z);
       i:=i+lowbit(i);
     end;
   end;

 procedure get(x,y:longint);
   var i:longint;
   begin
     e[y]:=;
     st[,y]:=ph[x];
     i:=x;
     while i> do
     begin
       if h[i]<> then
       begin
         inc(e[y]);
         st[e[y],y]:=h[i];
       end;
       i:=i-lowbit(i);
     end;
   end;

 function sum:longint;
   var i,j:longint;
   begin
     sum:=;
     for j:= to  do
       for i:= to e[j] do
         if (j<=) then
           sum:=sum+tree[tree[st[i,j]].r].s
         else sum:=sum-tree[tree[st[i,j]].r].s;//u,v路径上的情况为tree[u]+tree[v]-tree[lca(u,v)]-tree[fa[lca(u,v)]];
   end;

 function getans(l,r,k:longint):longint;
   var m,s,i,j:longint;
   begin
     if l=r then exit(sa[l])
     else begin
       m:=(l+r) shr ;
       s:=sum;
       if s>=k then
       begin
         for j:= to  do
           for i:= to e[j] do
             st[i,j]:=tree[st[i,j]].r;
         exit(getans(m+,r,k));
       end
       else begin
         k:=k-s;
         for j:= to  do
           for i:= to e[j] do
             st[i,j]:=tree[st[i,j]].l;
         exit(getans(l,m,k));
       end;
     end;
   end;

 begin
   readln(n,m);
   for i:= to n do
   begin
     read(g[i]);
     a[i]:=g[i];
   end;
   s:=n;
   for i:= to n- do
   begin
     readln(x,y);
     add(x,y);
     add(y,x);
   end;

   for i:= to m do
   begin
     readln(q[i].z,q[i].x,q[i].y);
     if q[i].z= then
     begin
       inc(s);
       a[s]:=q[i].y;
     end
     else begin
       addq(q[i].x,q[i].y,i);
       addq(q[i].y,q[i].x,i);
     end;
   end;
   sort(,s);
   p:=;
   sa[]:=a[];
   for i:= to s do
     if a[i]<>a[i-] then  //离散化
     begin
       inc(p);
       sa[p]:=a[i];
     end;

   for i:= to n do
     a[i]:=i;
   dfs();
   t:=;
   h[]:=build(,p);
   ph[]:=h[];
   for i:= to n do
   begin
     loc[i]:=find(g[b[i]]);
     y:=fa[b[i]];
     ph[i]:=insert(ph[c[y]],loc[i],,p,);  //建立未修改前的主席树
   end;
   for i:= to m do
   begin
     if q[i].z<> then
     begin
       z:=an[i];
       get(c[q[i].x],);  //提取区间
       get(c[q[i].y],);
       get(c[z],);
       get(c[fa[z]],);
       s:=;
       for j:= to  do
       begin
         for k:= to e[j] do
           if (j<=) then
             s:=s+tree[st[k,j]].s
           else s:=s-tree[st[k,j]].s;
       end;
       if s<q[i].z then writeln('invalid request!')
       else writeln(getans(,p,q[i].z));
     end
     else begin
       x:=q[i].x;
       work(c[x],loc[c[x]],-);
       work(cc[x]+,loc[c[x]],);
       loc[c[x]]:=find(q[i].y);
       work(c[x],loc[c[x]],);
       work(cc[x]+,loc[c[x]],-);
     end;
   end;
 end.