POJ 3259 Wormholes

类似于 POJ1860 求解负权回路问题，不过考虑到图可能不连通，所以需添加一个超级节点，与各顶点的初始距离均为1000

 

  
    

   
     
   
     #include 
   
     <
   
     iostream
   
     >
   
     

   
     using
   
      
   
     namespace
   
      std;


   
     int
   
      main()
{
 
   
     int
   
      F, N , M, W, S, E, T;
 
   
     int
   
      path[
   
     5300
   
     ][
   
     3
   
     ];
 
   
     int
   
      dist[
   
     501
   
     ];
 cin 
   
     >>
   
      F;
 
   
     while
   
      (F
   
     --
   
     )
 {
 cin 
   
     >>
   
      N 
   
     >>
   
      M 
   
     >>
   
      W;
 
   
     int
   
      size 
   
     =
   
      
   
     0
   
     ;
 
   
     for
   
      (
   
     int
   
      i 
   
     =
   
      
   
     0
   
     ; i 
   
     <
   
      M; i
   
     ++
   
     )
 {
 cin 
   
     >>
   
      S 
   
     >>
   
      E 
   
     >>
   
      T;
 path[size][
   
     0
   
     ] 
   
     =
   
      S;
 path[size][
   
     1
   
     ] 
   
     =
   
      E;
 path[size
   
     ++
   
     ][
   
     2
   
     ] 
   
     =
   
      T;

 path[size][
   
     0
   
     ] 
   
     =
   
      E;
 path[size][
   
     1
   
     ] 
   
     =
   
      S;
 path[size
   
     ++
   
     ][
   
     2
   
     ] 
   
     =
   
      T;
 }
 
   
     for
   
      (
   
     int
   
      i 
   
     =
   
      
   
     0
   
     ; i 
   
     <
   
      W; i
   
     ++
   
     )
 {
 cin 
   
     >>
   
      S 
   
     >>
   
      E 
   
     >>
   
      T;
 path[size][
   
     0
   
     ] 
   
     =
   
      S;
 path[size][
   
     1
   
     ] 
   
     =
   
      E;
 path[size
   
     ++
   
     ][
   
     2
   
     ] 
   
     =
   
      
   
     -
   
     T;
 }
 fill(
   
     &
   
     dist[
   
     0
   
     ], 
   
     &
   
     dist[N], 
   
     1000
   
     );

 
   
     bool
   
      isChanged 
   
     =
   
      
   
     true
   
     ;
 
   
     for
   
      (
   
     int
   
      i 
   
     =
   
      
   
     0
   
     ; i 
   
     <
   
      N 
   
     &&
   
      isChanged; i
   
     ++
   
     )
 {
 isChanged 
   
     =
   
      
   
     false
   
     ;
 
   
     for
   
      (
   
     int
   
      j 
   
     =
   
      
   
     0
   
     ; j 
   
     <
   
      size; j
   
     ++
   
     )
 {
 
   
     if
   
      (dist[path[j][
   
     1
   
     ]] 
   
     >
   
      dist[path[j][
   
     0
   
     ]] 
   
     +
   
      path[j][
   
     2
   
     ])
 {
 dist[path[j][
   
     1
   
     ]] 
   
     =
   
      dist[path[j][
   
     0
   
     ]] 
   
     +
   
      path[j][
   
     2
   
     ];
 isChanged 
   
     =
   
      
   
     true
   
     ;
 }
 }
 }
 cout 
   
     <<
   
      (isChanged 
   
     ?
   
      (
   
     "
   
     YES
   
     "
   
     ) : (
   
     "
   
     NO
   
     "
   
     )) 
   
     <<
   
      endl;
 }
 
   
     return
   
      
   
     0
   
     ;
}