bzoj1267 3784

双倍经验题
像这种方案太多不能全部求出来但求前k大一般有这样一个思路
将所有方案无重复不漏的分为若干类，每个类的元素满足单调性，然后我们用堆维护就行了！
对于这道题，可以想到用树的分治来处理路径，当处理根为x时
我们处理当前的子树每个点i和之前的子树上的组成的路径，
我们完全可以把访问顺序状态记录成一条链（状态是nlogn规模不会爆）
当前子树的每个点i在链上都有一段连续的可选区间，这个区间的点和i构成一条过根x的路径
这样链上的每个点就代表了一类路径
很明显，我们就可以noi超级钢琴的做法来解决，st表预处理+堆维护

type way=record
       po,num,next:longint;
     end;
     node=record
       l,r,s,t:longint;
     end;

var e:array[0..100010] of way;
    h:array[0..1000010] of node;
    w:array[0..1000010,0..20] of longint;
    d:array[0..20] of longint;
    a:array[0..1000010] of longint;
    q:array[0..1000010,0..1] of longint;
    f,p,s:array[0..50010] of longint;
    v:array[0..50010] of boolean;
    l,r,root,len,t,tot,i,n,k,x,y,z,j:longint;
    m:node;

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

function mx(x,y:longint):longint;
  begin
    if a[x]>a[y] then exit(x) else exit(y);
  end;

function ask(x,y:longint):longint;
  var k:longint;
  begin
    k:=trunc(ln(y-x+1)/ln(2));
    exit(mx(w[x,k],w[y-d[k]+1,k]));
  end;

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

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

procedure up(i:longint);
  var j:longint;
  begin
    j:=i shr 1;
    while j>0 do
    begin
      if a[h[j].s]+a[h[j].t]<a[h[i].s]+a[h[i].t] then
      begin
        swap(h[i],h[j]);
        i:=j;
        j:=j shr 1;
      end
      else break;
    end;
  end;

procedure sift(i:longint);
  var j:longint;
  begin
    j:=i shl 1;
    while j<=t do
    begin
      if (j<t) and (a[h[j+1].s]+a[h[j+1].t]>a[h[j].s]+a[h[j].t]) then inc(j);
      if a[h[j].s]+a[h[j].t]>a[h[i].s]+a[h[i].t] then
      begin
        swap(h[i],h[j]);
        i:=j;
        j:=j shl 1;
      end
      else break;
    end;
  end;

procedure getroot(x,fa:longint);
  var i,y:longint;
  begin
    s[x]:=1;
    f[x]:=0;
    i:=p[x];
    while i<>0 do
    begin
      y:=e[i].po;
      if (y<>fa) and not v[y] then
      begin
        getroot(y,x);
        s[x]:=s[x]+s[y];
        f[x]:=max(f[x],s[y]);
      end;
      i:=e[i].next;
    end;
    f[x]:=max(f[x],tot-s[x]);
    if f[x]<f[root] then root:=x;
  end;

procedure get(x,fa,len:longint);
  var i,y:longint;
  begin
    inc(t);
    a[t]:=len;
    q[t,0]:=l; q[t,1]:=r;
    i:=p[x];
    while i<>0 do
    begin
      y:=e[i].po;
      if (y<>fa) and not v[y] then get(y,x,len+e[i].num);
      i:=e[i].next;
    end;
  end;

procedure work(x:longint);
  var i,y:longint;
  begin
    v[x]:=true;
    i:=p[x];
    inc(t);
    l:=t;
    r:=t;
    q[t,0]:=l; q[t,1]:=r;
    while i<>0 do
    begin
      y:=e[i].po;
      if not v[y] then
      begin
        r:=t;
        get(y,x,e[i].num);
      end;
      i:=e[i].next;
    end;
    i:=p[x];
    while i<>0 do
    begin
      y:=e[i].po;
      if not v[y] then
      begin
        root:=0;
        tot:=s[y];
        getroot(y,0);
        work(root);
      end;
      i:=e[i].next;
    end;
  end;

begin
  readln(n,k);
  for i:=1 to n-1 do
  begin
    readln(x,y,z);
    add(x,y,z);
    add(y,x,z);
  end;
  f[0]:=2147483647;
  tot:=n;
  getroot(1,0);
  work(root);
  tot:=trunc(ln(t)/ln(2));
  d[0]:=1;
  for i:=1 to tot do
    d[i]:=d[i-1]*2;

  for i:=1 to t do
    w[i,0]:=i;
  for j:=1 to tot do
    for i:=1 to t do
      if i+d[j]-1<=t then
        w[i,j]:=mx(w[i,j-1],w[i+d[j-1],j-1])
      else break;

  tot:=t; t:=0;
  for i:=1 to tot do
  begin
    inc(t);
    with h[t] do
    begin
      l:=q[i,0]; r:=q[i,1];
      s:=i;
      t:=ask(l,r);
    end;
    up(t);
  end;
  for i:=1 to k do
  begin
    writeln(a[h[1].s]+a[h[1].t]);
    swap(h[1],h[t]);
    m:=h[t];
    dec(t);
    sift(1);
    if m.t>m.l then
    begin
      inc(t);
      with h[t] do
      begin
        l:=m.l; r:=m.t-1;
        s:=m.s;
        t:=ask(l,r);
      end;
      up(t);
    end;
    if m.t<m.r then
    begin
      inc(t);
      with h[t] do
      begin
        l:=m.t+1; r:=m.r;
        s:=m.s;
        t:=ask(l,r);
      end;
      up(t);
    end;
  end;
end.