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=;
 type way=record
        po,len,next:longint;
      end;
      node=record
        loc,num:longint;
      end;

 var heap:array[..] of node;
     w,e:array[..] of way;
     can:array[..] of boolean;
     ans,fa,f,dep,from,d,p,where:array[..] 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 ];
     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-;
       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 ;
     while j> 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 ;
       end
       else break;
     end;
   end;

 procedure sift(i:longint);
   var j,x,y:longint;
   begin
     j:=i shl ;
     while j<=t do
     begin
       if (j<t) and (heap[j].num>heap[j+].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 ;
       end
       else break;
     end;
   end;

 procedure dij;
   var i,j,mid,x,y:longint;
   begin
     fillchar(from,sizeof(from),);
     d[]:=;
     where[]:=;
     heap[].loc:=;
     heap[].num:=;
     for i:= to n do
     begin
       where[i]:=i;
       d[i]:=inf;
       heap[i].num:=inf;
       heap[i].loc:=i;
     end;
     for i:= to n- do
     begin
       x:=heap[].loc;
       mid:=heap[].num;
       y:=heap[t].loc;
       where[y]:=;
       change(heap[],heap[t]);
       dec(t);
       sift();
       j:=p[x];
       while j<>- do
       begin
         y:=w[j].po;
         if d[y]>mid+w[j].len then
         begin
           fa[y]:=x;
           dep[y]:=dep[x]+;
           d[y]:=mid+w[j].len;
           if from[y]<>- then
           begin
             can[from[y]]:=false;
             can[from[y] xor ]:=false;
           end;
           from[y]:=j;
           can[j]:=true;
           can[j xor ]:=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:=-;
     py:=-;
     while getf(x)<>getf(y) do
     begin
       if dep[x]<dep[y] then
       begin
         swap(x,y);
         swap(px,py);
       end;
       if ans[x]=- then
       begin
         ans[x]:=z-d[x];
         if px<>- then f[px]:=x;
       end
       else
         if px<>- then f[px]:=getf(x);
       px:=getf(x);
       x:=fa[px];
     end;
   end;

 begin
   t:=-;
   fillchar(p,sizeof(p),);
   readln(n,m);
   for i:= to m do
   begin
     readln(x,y,z);
     add(x,y,z);
     add(y,x,z);
   end;
   t:=n;
   dij;
   t:=;
   for i:= to n do
   begin
     j:=p[i];
     f[i]:=i;
     while j<>- 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 ]:=true;
       end;
       j:=w[j].next;
     end;
   end;
   sort(,t);
   fillchar(ans,sizeof(ans),);
   for i:= to t do
     calc(e[i].po,e[i].next,e[i].len);
   for i:= to n do
     writeln(ans[i]);
 end.