POJ 2240 Arbitrage

解题思路: Bellman-Ford算法，求解负权回路问题，考虑到图的不连通性，添加一个超级初始点，到各顶点汇率均为1：

  
    

   
     
   
     #include 
   
     <
   
     iostream
   
     >
   
     
#include 
   
     <
   
     map
   
     >
   
     
#include 
   
     <
   
     string
   
     >
   
     

   
     using
   
      
   
     namespace
   
      std;


   
     int
   
      main()
{
 
   
     int
   
      N, M , L 
   
     =
   
      
   
     1
   
     ;
 
   
     double
   
      rate;
 
   
     string
   
      curStr, curStr1, curStr2;
 map
   
     <
   
     string
   
     , 
   
     int
   
     >
   
     name;
 
   
     double
   
      dist[
   
     305
   
     ];

 
   
     struct
   
      
 {
 
   
     int
   
      u,v;
 
   
     double
   
      rate;
 }edge[
   
     1000
   
     ];

 
   
     while
   
      (cin 
   
     >>
   
      N 
   
     &&
   
      N)
 {
 fill(
   
     &
   
     dist[
   
     0
   
     ], 
   
     &
   
     dist[
   
     304
   
     ], 
   
     1000.0
   
     );
 
   
     for
   
      (
   
     int
   
      i 
   
     =
   
      
   
     1
   
     ; i 
   
     <=
   
      N; i
   
     ++
   
     )
 {
 cin 
   
     >>
   
      curStr;
 name[curStr] 
   
     =
   
      i;
 }
 cin 
   
     >>
   
      M;
 
   
     for
   
      (
   
     int
   
      i 
   
     =
   
      
   
     0
   
     ; i 
   
     <
   
      M; i
   
     ++
   
     )
 {
 cin 
   
     >>
   
      curStr1 
   
     >>
   
      rate 
   
     >>
   
      curStr2;
 edge[i].u 
   
     =
   
      name[curStr1];
 edge[i].v 
   
     =
   
      name[curStr2];
 edge[i].rate 
   
     =
   
      rate;
 }
 
   
     bool
   
      isChanged 
   
     =
   
      
   
     true
   
     ;
 
   
     for
   
      (
   
     int
   
      i 
   
     =
   
      
   
     0
   
     ; i 
   
     <
   
      N 
   
     &&
   
      isChanged; i
   
     ++
   
     )
 {
 isChanged 
   
     =
   
      
   
     false
   
     ;
 
   
     for
   
      (
   
     int
   
      j 
   
     =
   
      
   
     0
   
     ; j 
   
     <
   
      M; j
   
     ++
   
     )
 {
 
   
     if
   
      (dist[edge[j].v] 
   
     <
   
      dist[edge[j].u] 
   
     *
   
      edge[j].rate)
 {
 dist[edge[j].v] 
   
     =
   
      dist[edge[j].u] 
   
     *
   
      edge[j].rate;
 isChanged 
   
     =
   
      
   
     true
   
     ;
 }
 }
 }
 name.clear();
 cout 
   
     <<
   
     "
   
     Case 
   
     "
   
      
   
     <<
   
      L 
   
     <<
   
      (isChanged 
   
     ?
   
      (
   
     "
   
     : Yes
   
     "
   
     ) : (
   
     "
   
     : No
   
     "
   
     )) 
   
     <<
   
      endl;
 L
   
     ++
   
     ;
 }
 
   
     return
   
      
   
     0
   
     ;
}