poj3519

凡是差分约束系统的题目
都是转化为d[j]-d[i]<=w[i,j]的形式
然后我们建立边i-->j 边权为w[i,j]
对于这道题，要求d[n]-d[1]尽可能的大
设d[i]为相对差，d[1]=0，我们只要跑1-->n的最短路即可（为什么是最短路呢？实在不明白简单举一个例子即可）
由于这道题边不存在负权，所以我们用dij+heap更合适

 const inf=;
 type link=^node;
      node=record
        po,len:longint;
        next:link;
      end;
      point=record
        num,loc:longint;
      end;

 var w:array[..] of link;
     heap:array[..] of point;
     where,d:array[..] of longint;
     z,t,s,i,j,n,m,x,y:longint;
     p:link;

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

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

 procedure add(x,y,z:longint);
   var p:link;
   begin
     new(p);
     p^.po:=y;
     p^.len:=z;
     p^.next:=w[x];
     w[x]:=p;
   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;
         swap(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<=s do
     begin
       if (j+<=s) 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;
         swap(heap[i],heap[j]);
         i:=j;
         j:=i shl ;
       end
       else break;
     end;
   end;

 procedure dij;
   var p:link;
       mid,k,y:longint;
   begin
     p:=w[];
     for i:= to t do
       d[i]:=inf;
     d[]:=;
     while p<>nil do
     begin
       x:=p^.po;
       d[x]:=min(d[x],p^.len);
       p:=p^.next;
     end;
     s:=;
     for i:= to t do
     begin
       inc(s);
       heap[s].num:=d[i];
       heap[s].loc:=i;
       where[i]:=s;
       up(s);
     end;

     for k:= to t do
     begin
       mid:=heap[].num;
       if s= then break;
       if mid=inf then break;
       x:=heap[].loc;
       y:=heap[s].loc;
       where[y]:=;

       swap(heap[],heap[s]);
       dec(s);

       sift();
       p:=w[x];
       while p<>nil do
       begin
         y:=p^.po;
         if d[y]>p^.len+mid then
         begin
           d[y]:=p^.len+mid;
           heap[where[y]].num:=d[y];
           up(where[y]);
         end;
         p:=p^.next;
       end;
     end;
   end;

 begin
   readln(t,m);
   for i:= to m do
   begin
     readln(x,y,z);
     add(x,y,z);
   end;
   dij;
   writeln(d[t]);
 end.