bzoj1576 3694

两道题目本质是一样的
bzoj1576我们先要用dij+heap处理出最短路径树和起点到每个点的最短路径
而bzoj3694已经给出了最短路径树，所以直接dfs即可
题目要求的是不走起点到每个点最短路径上的最后一条边的最短路径
首先我们考虑非树边的影响，对于一条非树边(u,v)，加入到最短路径树中
必然会形成一个环，对于除了LCA(u,v)以外环上的点i，走边(u,v)的最短路径长度为d[u]+w(u,v)+d[v]-d[i]
显然我们只要穷举每个非树边，然后更新每个点可行的最短路径长度即可
裸的想法当然是可以用树链剖分+线段树来完成
但是我们有更好的想法，考虑我们用最小化d[u]+w(u,v)+d[v]即可
因此我们对每条边以d[u]+w(u,v)+d[v]为关键字从小到大排序
显然，按照这个顺序当前边更新的点一定已经是最优的
我们可以考虑用并查集维护，避免点被重复更新

const inf=2000000007;
type way=record
       po,len,next:longint;
     end;
     node=record
       loc,num:longint;
     end;

var heap:array[0..100010] of node;
    w,e:array[0..400010] of way;
    can:array[0..400010] of boolean;
    ans,fa,f,dep,from,d,p,where:array[0..100010] of longint;
    j,i,n,m,t,x,y,z:longint;

procedure change(var a,b:node);
  var c:node;
  begin
    c:=a;
    a:=b;
    b:=c;
  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: longint;
      x,y:way;
  begin
    i:=l;
    j:=r;
    x:=e[(l+r) shr 1];
    repeat
      while e[i].len<x.len do inc(i);
      while x.len<e[j].len do dec(j);
      if not(i>j) then
      begin
        y:=e[i];
        e[i]:=e[j];
        e[j]:=y;
        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 getf(x:longint):longint;
  begin
    if f[x]<>x then f[x]:=getf(f[x]);
    exit(f[x]);
  end;

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

procedure up(i:longint);
  var j,x,y:longint;
  begin
    j:=i shr 1;
    while j>0 do
    begin
      if heap[i].num<heap[j].num then
      begin
        x:=heap[i].loc;
        y:=heap[j].loc;
        where[x]:=j;
        where[y]:=i;
        change(heap[i],heap[j]);
        i:=j;
        j:=i shr 1;
      end
      else break;
    end;
  end;

procedure sift(i:longint);
  var j,x,y:longint;
  begin
    j:=i shl 1;
    while j<=t do
    begin
      if (j<t) and (heap[j].num>heap[j+1].num) then inc(j);
      if heap[i].num>heap[j].num then
      begin
        x:=heap[i].loc;
        y:=heap[j].loc;
        where[x]:=j;
        where[y]:=i;
        change(heap[i],heap[j]);
        i:=j;
        j:=i shl 1;
      end
      else break;
    end;
  end;

procedure dij;
  var i,j,mid,x,y:longint;
  begin
    fillchar(from,sizeof(from),255);
    d[1]:=0;
    where[1]:=1;
    heap[1].loc:=1;
    heap[1].num:=0;
    for i:=2 to n do
    begin
      where[i]:=i;
      d[i]:=inf;
      heap[i].num:=inf;
      heap[i].loc:=i;
    end;
    for i:=1 to n-1 do
    begin
      x:=heap[1].loc;
      mid:=heap[1].num;
      y:=heap[t].loc;
      where[y]:=1;
      change(heap[1],heap[t]);
      dec(t);
      sift(1);
      j:=p[x];
      while j<>-1 do
      begin
        y:=w[j].po;
        if d[y]>mid+w[j].len then
        begin
          fa[y]:=x;
          dep[y]:=dep[x]+1;
          d[y]:=mid+w[j].len;
          if from[y]<>-1 then
          begin
            can[from[y]]:=false;
            can[from[y] xor 1]:=false;
          end;
          from[y]:=j;
          can[j]:=true;
          can[j xor 1]:=true;
          heap[where[y]].num:=d[y];
          up(where[y]);
        end;
        j:=w[j].next;
      end;
    end;
  end;

procedure calc(x,y,z:longint);
  var px,py:longint;
  begin
    px:=-1;
    py:=-1;
    while getf(x)<>getf(y) do
    begin
      if dep[x]<dep[y] then
      begin
        swap(x,y);
        swap(px,py);
      end;
      if ans[x]=-1 then
      begin
        ans[x]:=z-d[x];
        if px<>-1 then f[px]:=x;
      end
      else
        if px<>-1 then f[px]:=getf(x);
      px:=getf(x);
      x:=fa[px];
    end;
  end;

begin
  t:=-1;
  fillchar(p,sizeof(p),255);
  readln(n,m);
  for i:=1 to m do
  begin
    readln(x,y,z);
    add(x,y,z);
    add(y,x,z);
  end;
  t:=n;
  dij;
  t:=0;
  for i:=1 to n do
  begin
    j:=p[i];
    f[i]:=i;
    while j<>-1 do
    begin
      if not can[j] then
      begin
        inc(t);
        e[t].po:=i;
        e[t].next:=w[j].po;
        e[t].len:=w[j].len+d[i]+d[w[j].po];
        can[j xor 1]:=true;
      end;
      j:=w[j].next;
    end;
  end;
  sort(1,t);
  fillchar(ans,sizeof(ans),255);
  for i:=1 to t do
    calc(e[i].po,e[i].next,e[i].len);
  for i:=2 to n do
    writeln(ans[i]);
end.