bzoj3955

首先，最短路不同的两辆车一定不会发生堵塞

对于最短路相同的点，我们把属于最短路径上的边拎出来建图跑最大流即可

然后我TLE了……

因为很明显建出来图很大，而真正流的流量很小

普通的初始标号都是0的sap在增广的时候编号会非常慢

运用fanhq博客里的做法，先用dfs计算图的标号O(m+n)，然后再跑sap就跑得飞起了

 const inf=;
 type node=record
        po,next,flow:longint;
      end;
      point=record
        loc,num:longint;
      end;
      way=record
        po,next,num:longint;
      end;
 
 var w:array[..] of way;
     e:array[..] of node;
     h:array[..] of point;
     v:array[..] of boolean;
     wh,d,a,cur,hi,pre,p,q,numh:array[..] of longint;
     ans,j,i,len,n,m,t,c,x,y,z:longint;
 
 procedure swap(var a,b:point);
   var c:point;
   begin
     c:=a;
     a:=b;
     b:=c;
   end;
 
 procedure sift(i:longint);
   var j,x,y:longint;
   begin
     j:=i shl ;
     while j<=t do
     begin
       if (j<t) and (h[j].num>h[j+].num) then inc(j);
       if h[i].num>h[j].num then
       begin
         x:=h[i].loc;
         y:=h[j].loc;
         wh[x]:=j;
         wh[y]:=i;
         swap(h[i],h[j]);
         i:=j;
         j:=j shl ;
       end
       else break;
     end;
   end;
 
 procedure up(i:longint);
   var j,x,y:longint;
   begin
     j:=i shr ;
     while j> do
     begin
       if h[i].num<h[j].num then
       begin
         x:=h[i].loc;
         y:=h[j].loc;
         wh[x]:=j;
         wh[y]:=i;
         swap(h[i],h[j]);
         i:=j;
         j:=j shr ;
       end
       else break;
     end;
   end;
 
 procedure dij;
   var i,k,x,y:longint;
   begin
     t:=n;
     for i:= to n do
     begin
       if i= then d[i]:= else d[i]:=inf;
       wh[i]:=i;
       h[i].num:=d[i];
       h[i].loc:=i;
     end;
     for k:= to n- do
     begin
       x:=h[].loc;
       wh[h[t].loc]:=;
       swap(h[],h[t]);
       dec(t);
       sift();
       i:=q[x];
       while i<> do
       begin
         y:=w[i].po;
         if d[x]+w[i].num<d[y] then
         begin
           d[y]:=d[x]+w[i].num;
           h[wh[y]].num:=d[y];
           up(wh[y]);
         end;
         i:=w[i].next;
       end;
     end;
   end;
 
 function cmp(i,j:longint):boolean;
   begin
     if d[i]=d[j] then exit(i<j);
     exit(d[i]<d[j]);
   end;
 
 procedure sort(l,r:longint);
   var i,j,x,y:longint;
   begin
     i:=l;
     j:=r;
     x:=a[(l+r) shr ];
     repeat
       while cmp(a[i],x) do inc(i);
       while cmp(x,a[j]) do dec(j);
       if not(i>j) then
       begin
         y:=a[i]; a[i]:=a[j]; a[j]:=y;
         inc(i);
         dec(j);
       end;
     until i>j;
     if l<j then sort(l,j);
     if i<r then sort(i,r)
   end;
 
 procedure add(x,y,f:longint);
   begin
     inc(len);
     e[len].po:=y;
     e[len].flow:=f;
     e[len].next:=p[x];
     p[x]:=len;
   end;
 
 procedure build(x,y,f:longint);
   begin
     add(x,y,f);
     add(y,x,);
   end;
 
 procedure ins(x,y,z:longint);
   begin
     inc(len);
     w[len].po:=y;
     w[len].num:=z;
     w[len].next:=q[x];
     q[x]:=len;
   end;
 
 function sap(lim:longint):longint;
   var i,j,u,tmp,q:longint;
   begin
     u:=; sap:=;
     while hi[]<n+ do
     begin
       i:=cur[u];
       while i<>- do
       begin
         j:=e[i].po;
         if (e[i].flow>) and (hi[u]=hi[j]+) then
         begin
           pre[j]:=u;
           cur[u]:=i;
           u:=j;
           if u= then
           begin
             inc(sap);
             if sap=lim then exit;
             while u<> do
             begin
               u:=pre[u];
               j:=cur[u];
               dec(e[j].flow);
               inc(e[j xor ].flow);
             end;
           end;
           break;
         end;
         i:=e[i].next;
       end;
       if i=- then
       begin
         dec(numh[hi[u]]);
         if numh[hi[u]]= then break;
         tmp:=n;
         q:=-;
         i:=p[u];
         while i<>- do
         begin
           j:=e[i].po;
           if e[i].flow> then
             if hi[j]<tmp then
             begin
               q:=i;
               tmp:=hi[j];
             end;
           i:=e[i].next;
         end;
         cur[u]:=q;
         hi[u]:=tmp+;
         inc(numh[hi[u]]);
         if u<> then u:=pre[u];
       end;
     end;
   end;
 
 procedure dfs(x:longint);
   var tmp,i,y,q:longint;
   begin
     if x= then
     begin
       hi[]:=;
       inc(numh[]);
       exit;
     end;
     v[x]:=true;
     tmp:=n;
     q:=-;
     i:=p[x];
     while i<>- do
     begin
       y:=e[i].po;
       if e[i].flow> then
       begin
         if not v[y] then dfs(y);
         if hi[y]<tmp then
         begin
           tmp:=hi[y];
           q:=i;
         end;
       end;
       i:=e[i].next;
     end;
     cur[x]:=q;
     hi[x]:=tmp+;
     inc(numh[hi[x]]);
   end;
 
 procedure work(l,r:longint);
   var i,j:longint;
   begin
     len:=-;
     fillchar(p,sizeof(p),);
     for i:= to n do
     begin
       j:=q[i];
       while j<> do
       begin
         y:=w[j].po;
         if d[i]+w[j].num=d[y] then build(y,i,);
         j:=w[j].next;
       end;
     end;
     i:=l;
     while i<=r do
     begin
       j:=i+;
       while (j<=r) and (a[j]=a[i]) do inc(j);
       build(,a[i],j-i);
       i:=j;
     end;
     fillchar(numh,sizeof(numh),);
     fillchar(v,sizeof(v),false);
     dfs();
     if hi[]<n+ then
       ans:=ans+sap(r-l+);
   end;
 
 begin
   readln(n,m,c);
   for i:= to m do
   begin
     readln(x,y,z);
     ins(x,y,z);
     ins(y,x,z);
   end;
   dij;
   for i:= to c do
     read(a[i]);
   sort(,c);
   i:=;
   while i<=c do
   begin
     j:=i+;
     while (d[a[i]]=d[a[j]]) and (j<=c) do inc(j);
     if j=i+ then inc(ans)
     else if a[i]= then inc(ans,j-i)
     else work(i,j-);
     i:=j;
   end;
   writeln(ans);
 end.