bzoj3551 3545

我直接来讲在线好了

这是一个很巧妙的方法，把边作为一个点

做一遍最小生成树，当加如一条边时，我们把这条边两点x,y的并查集的根i,j的父亲都设为这条边代表的点k，由k向i，j连边

这样我们就构建出一棵树，这棵树的叶子都是原来节点

且每棵子树都是在子树根所代表的边的限制下的最小连通块

这样我们就可以通过dfs序（只用对叶子标号）+主席树来维护k大了并通过倍增找到限制

这两题都是一副卡pascal过不了的样子……QAQ

另外网上的一些标称（bzoj3551）似乎没有考虑一个点没有边可走，但询问k=1的情况，可以加数据cha

type node=record
       po,next:longint;
     end;
     way=record
       x,y,z:longint;
     end;
     point=record
       l,r,s:longint;
     end;

var e:array[0..400010] of node;
    w:array[0..500010] of way;
    v:array[0..400010] of boolean;
    anc:array[0..200010,0..20] of longint;
    d,l,r,p,fa,c,a,b,h:array[0..200010] of longint;
    tree:array[0..200010*20] of point;
    num,j,s,size,i,len,t,n,m,q,x,y,ans,k:longint;

function min(a,b:longint):longint;
  begin
    if a>b then exit(b) else exit(a);
  end;

function max(a,b:longint):longint;
  begin
    if a>b then exit(a) else exit(b);
  end;

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

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

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

procedure qsort(l,r:longint);
  var i,j,x:longint;
      y:way;
  begin
    i:=l;
    j:=r;
    x:=w[(l+r) shr 1].z;
    repeat
      while w[i].z<x do inc(i);
      while x<w[j].z do dec(j);
      if 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 qsort(l,j);
    if i<r then qsort(i,r);
  end;

procedure dfs(x:longint);
  var i,y:longint;
  begin
    v[x]:=true;
    if x<=n then
    begin
      inc(num);
      b[num]:=x;
      l[x]:=num;
      r[x]:=num;
      exit;
    end;
    i:=p[x];
    l[x]:=n;
    r[x]:=0;
    while i<>0 do
    begin
      y:=e[i].po;
      anc[y,0]:=x;
      dfs(y);
      l[x]:=min(l[x],l[y]);
      r[x]:=max(r[x],r[y]);
      i:=e[i].next;
    end;
  end;

function find(x,y:longint):longint;
  var i:longint;
  begin
    for i:=size downto 0 do
      if a[anc[x,i]]<=y then x:=anc[x,i];
    exit(x);
  end;

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

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

function ask(l,r,x,y,k:longint):longint;
  var m,s:longint;
  begin
    if l=r then exit(c[l])
    else begin
      m:=(l+r) shr 1;
      s:=tree[tree[y].r].s-tree[tree[x].r].s;
      if s>=k then exit(ask(m+1,r,tree[x].r,tree[y].r,k))
      else exit(ask(l,m,tree[x].l,tree[y].l,k-s));
    end;
  end;

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

begin
  readln(n,m,q);
  for i:=1 to n do
  begin
    read(d[i]);
    a[i]:=d[i];
    b[i]:=i;
  end;
  sort(1,n);
  s:=1;
  d[b[1]]:=1;
  c[1]:=a[1];
  for i:=2 to n do
  begin
    if a[i]<>a[i-1] then
    begin
      inc(s);
      c[s]:=a[i];
    end;
    d[b[i]]:=s;
  end;
  for i:=1 to 2*n do
    fa[i]:=i;
  for i:=1 to m do
    readln(w[i].x,w[i].y,w[i].z);

  qsort(1,m);
  t:=n;
  fillchar(a,sizeof(a),0);
  for i:=1 to m do
  begin
    x:=getf(w[i].x);
    y:=getf(w[i].y);
    if x<>y then
    begin
      inc(t);
      fa[x]:=t;
      fa[y]:=t;
      a[t]:=w[i].z;
      ins(t,x);
      ins(t,y);
      if t=2*n-1 then break;
    end;
  end;

  a[0]:=2147483647;
  len:=t;
  for i:=1 to len do
    if not v[i] then dfs(getf(i));
  size:=trunc(ln(len)/ln(2)+0.1);
  for j:=1 to size do
    for i:=1 to len do
    begin
      x:=anc[i,j-1];
      anc[i,j]:=anc[x,j-1];
    end;
  t:=0;
  h[0]:=build(1,s);
  for i:=1 to num do
    h[i]:=add(1,s,h[i-1],d[b[i]]);
  ans:=-1;
  for i:=1 to q do
  begin
    readln(x,y,k);
   { if ans<>-1 then
    begin
      x:=x xor ans;
      y:=y xor ans;
      k:=k xor ans;
    end;        }
    x:=find(x,y);
    if x<=n then
    begin
      if k=1 then ans:=c[d[x]]
      else ans:=-1;
    end
    else if tree[h[r[x]]].s-tree[h[l[x]-1]].s<k then ans:=-1
    else ans:=ask(1,s,h[l[x]-1],h[r[x]],k);
    writeln(ans);
  end;
end.