bzoj4009

这是一道神题，首先我们不难先到整体二分吧

下面的问题就是，求出对于每个水果，有多少盘子是他的子路径

直接考虑不是很容易，我们换个思路，考虑对于每个盘子，哪些水果能包含它

我们假设盘子a,b，dep[a]<dep[b]

如果b在a的子树内，不难发现，水果路径必须是一个点在b的子树内（包括b），一个在c的子树外（不包括c，c是ab路径上a下一个点）

否则 ，水果路径必须两个点分别在a,b子树内

子树问题不难想到dfs序，设子树x区间为l[x],r[x],盘子路径x,y(l[x]<l[y])满足条件为

则要满足x∈[1,l[c]-1],y∈[l[b],r[b]或x∈[l[b],r[b]], y∈[l[c]+1,n] 当b在a的子树内

否则x∈[l[a],r[a]],y∈[l[b],r[b]，把(x,y)看做一个点

也就是现在询问每个点被多少矩形覆盖（注意第一种情形两个矩形是不相交的，所以覆盖的矩形数目就是盘子数目

矩形覆盖的经典做法是把矩形(x0,y0),(x1,y1)看成4个带权值的点

(x0,y0) 1, (x0,y1+1) -1, (x1+1,y0) -1 (x1+1,y1+1) 1，

这样每个询问点最下方（包括边界）的点权值和就是覆盖询问点的矩形数目（画图可知）

而这个问题我们对一维排序，一维树状数组即可快速解决

type node=record
       po,next:longint;
     end;
     point=record
       x,y,id,z:longint;
     end;

var e:array[0..80010] of node;
    dep,ans,st,a,b,c,p,d:array[0..50010] of longint;
    anc:array[0..40010,0..18] of longint;
    q,w,tw:array[0..400010] of point;
    can,v:array[0..80010] of boolean;
    j,tot,t,x,y,z,i,len,n,m,k,xx:longint;

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

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

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

procedure dfs(x:longint);
  var i,y:longint;
  begin
    inc(t);
    a[x]:=t;
    i:=p[x];
    while i<>0 do
    begin
      y:=e[i].po;
      if a[y]=0 then
      begin
        anc[y,0]:=x;
        dep[y]:=dep[x]+1;
        dfs(y);
      end;
      i:=e[i].next;
    end;
    b[x]:=t;
  end;

function jump(x,d:longint):longint;
  var i:longint;
  begin
    for i:=16 downto 0 do
      if dep[x]-1 shl i>=d then x:=anc[x,i];
    exit(x);
  end;

function cmp(a,b:point):boolean;
  begin
    exit((a.x<b.x) or (a.x=b.x) and (a.y<b.y));
  end;

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

procedure sortw(l,r:longint);
  var i,j:longint;
      x,y:point;
  begin
    i:=l;
    j:=r;
    x:=w[(l+r) shr 1];
    repeat
      while cmp(w[i],x) do inc(i);
      while cmp(x,w[j]) do dec(j);
      if not(i>j) then
      begin
        y:=w[i]; w[i]:=w[j]; w[j]:=y;
        inc(i);
        dec(j);
      end;
    until i>j;
    if l<j then sortw(l,j);
    if i<r then sortw(i,r);
  end;

procedure sortq(l,r:longint);
  var i,j:longint;
      x,y:point;
  begin
    i:=l;
    j:=r;
    x:=q[(l+r) shr 1];
    repeat
      while cmp(q[i],x) do inc(i);
      while cmp(x,q[j]) do dec(j);
      if not(i>j) then
      begin
        y:=q[i]; q[i]:=q[j]; q[j]:=y;
        inc(i);
        dec(j);
      end;
    until i>j;
    if l<j then sortq(l,j);
    if i<r then sortq(i,r);
  end;

procedure open(x0,x1,y0,y1,z:longint);
  begin
    inc(x1); inc(y1);
    inc(t); w[t].x:=x0; w[t].y:=y0; w[t].id:=1; w[t].z:=z;
    inc(t); w[t].x:=x0; w[t].y:=y1; w[t].id:=-1; w[t].z:=z;
    inc(t); w[t].x:=x1; w[t].y:=y0; w[t].id:=-1; w[t].z:=z;
    inc(t); w[t].x:=x1; w[t].y:=y1; w[t].id:=1; w[t].z:=z;
  end;

procedure work(x,w:longint);
  begin
    while x<=n+1 do
    begin
      if not v[x] then
      begin
        v[x]:=true;
        inc(tot);
        st[tot]:=x;
      end;
      d[x]:=d[x]+w;
      x:=x+lowbit(x);
    end;
  end;

function ask(x:longint):longint;
  begin
    ask:=0;
    while x>0 do
    begin
      ask:=ask+d[x];
      x:=x-lowbit(x);
    end;
  end;

procedure cdq(opx,opy,qx,qy,l,r:longint);
  var m,t,i,j,s,f1,f2,z,q1,q2:longint;
  begin
    if (l>r) or (qx>qy) then exit;
    if l=r then
    begin
      for i:=qx to qy do
        ans[q[i].id]:=c[l];
      exit;
    end;
    m:=(l+r) shr 1;  //二分答案
    t:=0;
    for i:=opx to opy do
      if w[i].z<=c[m] then
      begin
        inc(t);
        tw[t]:=w[i];
      end;

    z:=0;
    j:=1;
    for i:=qx to qy do
    begin
      can[i]:=false;
      while (j<=t) and (tw[j].x<=q[i].x) do  //扫描询问
      begin
        work(tw[j].y,tw[j].id);
        inc(j);
      end;
      s:=ask(q[i].y);
      if s>=q[i].z then
      begin
        ans[q[i].id]:=c[m];
        inc(z);
        can[i]:=true;
      end
      else q[i].z:=q[i].z-s;
    end;
    f1:=opx-1; f2:=opx+t-1;  //划分操作区间
    for i:=opx to opy do
      if w[i].z<=c[m] then
      begin
        inc(f1);
        tw[f1]:=w[i];
      end
      else begin
        inc(f2);
        tw[f2]:=w[i];
      end;
    for i:=opx to opy do
      w[i]:=tw[i];
    q1:=qx-1; q2:=qx+z-1;
    for i:=qx to qy do
      if can[i] then
      begin
        inc(q1);
        tw[q1]:=q[i];
      end
      else begin
        inc(q2);
        tw[q2]:=q[i];
      end;
    for i:=qx to qy do
      q[i]:=tw[i];
    for i:=1 to tot do
    begin
      s:=st[i];
      v[s]:=false;
      d[s]:=0;
    end;
    tot:=0;
    cdq(opx,f1,qx,q1,l,m);
    cdq(f1+1,opy,q1+1,qy,m+1,r);
  end;

begin
  readln(n,m,k);
  for i:=1 to n-1 do
  begin
    readln(x,y);
    add(x,y);
    add(y,x);
  end;
  dfs(1);
  for j:=1 to trunc(ln(n)/ln(2))+1 do
    for i:=1 to n do
    begin
      x:=anc[i,j-1];
      anc[i,j]:=anc[x,j-1];
    end;

  t:=0;
  for i:=1 to m do
  begin
    readln(x,y,z);
    if a[x]>a[y] then swap(x,y);
    if a[y]<=b[x] then
    begin
      xx:=jump(y,dep[x]+1);
      if a[xx]<>1 then open(1,a[xx]-1,a[y],b[y],z);
      if b[xx]<n then open(a[y],b[y],b[xx]+1,n,z);
    end
    else open(a[x],b[x],a[y],b[y],z);
    c[i]:=z;
  end;
  sortc(1,m);
  sortw(1,t);
  for i:=1 to k do
  begin
    readln(x,y,z);
    if a[x]>a[y] then swap(x,y);
    q[i].x:=a[x]; q[i].y:=a[y]; q[i].id:=i; q[i].z:=z;
  end;
  sortq(1,k);
  cdq(1,t,1,k,1,m);
  for i:=1 to k do
    writeln(ans[i]);
end.