bzoj2588

一开始一看树上的操作，就无脑写了树链剖分+主席树

然后果断T了，因为树链剖分+主席树必然带来两个log的复杂度

而且树链剖分复杂度还比较大……

后来发现其实没必要，在这道题，我们可以直接利用主席树维护

只不过，每个点维护的是它到它的祖先上数值出现的个数

则u,v之间各个数值出现的数值=tree[u]+tree[v]-tree[lca(u,v)]-tree[fa[lca(u,v)]];

这是一个满足区间减法的问题所以可以这么做

总结一下，在静态树上（相对于动态树而言，没有改变树的形态）

1. 如果问题满足区间减法性质，如求k大，那就直接做，或者用dfs序（下篇再写）

2. 如果不满足，那就要套树链剖分了

const maxn=100010;
type node=record
       po,next:longint;
     end;
     point=record
       l,r,s:longint;
     end;

var tree:array[0..maxn*20] of point;
    w:array[0..2*maxn] of node;
    h,p,c,b,a,q1,q2,rank,sa,fa,d:array[0..maxn] of longint;
    anc:array[0..maxn,0..20] of longint;
    j,t,z,e,i,n,m,k,x,y,len,ans,s:longint;

procedure swap(var a,b:longint);
  var c:longint;
  begin
    c:=a;
    a:=b;
    b:=c;
  end;

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

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

procedure sort(l,r: longint);
  var i,j,x:longint;
  begin
    i:=l;
    j:=r;
    x:=a[(l+r) div 2];
    repeat
      while (a[i]<x) do inc(i);
      while (x<a[j]) do dec(j);
      if not(i>j) then
      begin
        swap(a[i],a[j]);
        swap(c[i],c[j]);
        inc(i);
        j:=j-1;
      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 q,m:longint;
  begin
    inc(t);
    if l=r then exit(t)
    else begin
      q:=t;
      m:=(l+r) shr 1;
      tree[q].l:=build(l,m);
      tree[q].r:=build(m+1,r);
      exit(q);
    end;
  end;

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

function getans(l,r,k:longint):longint;
  var i,m,s1:longint;
  begin
    if l=r then
      exit(sa[l])
    else begin
      m:=(l+r) shr 1;
      s1:=tree[tree[x].l].s+tree[tree[y].l].s-tree[tree[z].l].s-tree[tree[e].l].s;
      if s1>=k then
      begin
        x:=tree[x].l;
        y:=tree[y].l;
        z:=tree[z].l;
        e:=tree[e].l;
        exit(getans(l,m,k));
      end
      else begin
        x:=tree[x].r;
        y:=tree[y].r;
        z:=tree[z].r;
        e:=tree[e].r;
        k:=k-s1;
        exit(getans(m+1,r,k));
      end;
    end;
  end;

function lca(x,y:longint):longint;
  var i,p:longint;
  begin
    if d[x]<d[y] then swap(x,y);
    if x=y then exit(x);
    p:=trunc(ln(d[x])/ln(2));
    for i:=p downto 0 do
      if d[x]-1 shl i>=d[y] then x:=anc[x,i];
    if x=y then exit(x);
    for i:=p downto 0 do
      if (anc[x,i]<>anc[y,i]) and (anc[x,i]<>0) then
      begin
        x:=anc[x,i];
        y:=anc[y,i];
      end;
    exit(fa[x]);
  end;

procedure dfs(x:longint);
  var i,y:longint;
  begin
    h[x]:=add(h[fa[x]],1,s,rank[x]);
    i:=p[x];
    while i<>0 do
    begin
      y:=w[i].po;
      if fa[x]<>y then
      begin
        d[y]:=d[x]+1;
        fa[y]:=x;
        dfs(y);
      end;
      i:=w[i].next;
    end;
  end;

begin
  readln(n,m);
  for i:=1 to n do
  begin
    read(a[i]);
    c[i]:=i;
  end;
  sort(1,n);
  s:=1;
  sa[1]:=a[1];
  rank[c[1]]:=1;
  for i:=2 to n do
  begin
    if a[i]<>a[i-1] then
    begin
      inc(s);
      sa[s]:=a[i];
    end;
    rank[c[i]]:=s;
  end;
  for i:=1 to n-1 do
  begin
    readln(x,y);
    add(x,y);
    add(y,x);
  end;
  h[0]:=build(1,s);
  dfs(1);

  for i:=1 to n do
    anc[i,0]:=fa[i];
  k:=trunc(ln(n)/ln(2));
  for j:=1 to k do
    for i:=1 to n do
    begin
      x:=anc[i,j-1];
      if x<>0 then anc[i,j]:=anc[x,j-1];
    end;

  ans:=0;
  for i:=1 to m do
  begin
    readln(x,y,k);
    x:=x xor ans;
    z:=lca(x,y);
    e:=h[fa[z]];
    z:=h[z];
    x:=h[x];
    y:=h[y];
    ans:=getans(1,s,k);
    write(ans);
    if i<>m then writeln;
  end;
end.