【HDOJ1217】【Floyd求最长路】

http://acm.hdu.edu.cn/showproblem.php?pid=1217

Arbitrage

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 9455    Accepted Submission(s): 4359

Problem Description

Arbitrage is the use of discrepancies in currency exchange rates to transform one unit of a currency into more than one unit of the same currency. For example, suppose that 1 US Dollar buys 0.5 British pound, 1 British pound buys 10.0 French francs, and 1 French franc buys 0.21 US dollar. Then, by converting currencies, a clever trader can start with 1 US dollar and buy 0.5 * 10.0 * 0.21 = 1.05 US dollars, making a profit of 5 percent.

Your job is to write a program that takes a list of currency exchange rates as input and then determines whether arbitrage is possible or not.

 

Input

The input file will contain one or more test cases. Om the first line of each test case there is an integer n (1<=n<=30), representing the number of different currencies. The next n lines each contain the name of one currency. Within a name no spaces will appear. The next line contains one integer m, representing the length of the table to follow. The last m lines each contain the name ci of a source currency, a real number rij which represents the exchange rate from ci to cj and a name cj of the destination currency. Exchanges which do not appear in the table are impossible.
Test cases are separated from each other by a blank line. Input is terminated by a value of zero (0) for n. 

 

Output

For each test case, print one line telling whether arbitrage is possible or not in the format "Case case: Yes" respectively "Case case: No". 

 

Sample Input

3
USDollar
BritishPound
FrenchFranc
3
USDollar 0.5 BritishPound
BritishPound 10.0 FrenchFranc
FrenchFranc 0.21 USDollar

3
USDollar
BritishPound
FrenchFranc
6
USDollar 0.5 BritishPound
USDollar 4.9 FrenchFranc
BritishPound 10.0 FrenchFranc
BritishPound 1.99 USDollar
FrenchFranc 0.09 BritishPound
FrenchFranc 0.19 USDollar

0

 

Sample Output

Case 1: Yes

Case 2: No

题目大意：给一堆国家的名字然后给一些国家的货币汇率，然后问能否通过一些转换，使自己获利。

题目分析：可以转化为求最长路问题，也就是求从起点到起点的最长路【只不过每次移动不是加法而是乘法】，看这条路最长能否超过1。也就是说求多起点多终点的最长路，并且由于汇率有大于一的和小于一的，就相当于负权边，所以不能使用DIJ算法，而且是多起点多终点的且数据规模不大，故使用Floyd算法最好。

【Floyd模板：最外层    K   次外层   I 最内层 J  转移方程： qwq[ I ][ J ]  =   max(  qwq[ I ][ J ]   ,  qwq[ I ][ K ] +  qwq[ K ][ J ]   )   也就是最外层的变量作为  "中间变量"  来更新内层】

 #include<iostream>
 #include<cstring>
 #include<cstdio>
 #include<algorithm>
 using namespace std;
 int n;
 char ss[][];
 double qwq[][];
 int find(char dd[])
 {
     for(int i =  ; i< n ;i++)
     {
         if(strcmp(dd,ss[i])==)return i;
     }
 }
 int main()
 {
     int case1=;
     while(scanf("%d",&n)&&n)
     {
         memset(qwq,,sizeof(qwq));
         for(int i =  ; i< n ; i++)
         {
             scanf("%s",ss[i]);
             qwq[i][i]=;
         }
         int m;
         scanf("%d",&m);
         while(m--)
         {
             char qq[],ww[];
             double asd;
             scanf("%s%lf%s",qq,&asd,ww);
             int u=find(qq);
             int v=find(ww);
             qwq[u][v]=asd;
         }
         for(int i =  ; i < n ; i++)
         {
             for(int j =  ; j < n; j++)
             {
                 for(int k =  ; k< n ; k++)
                 {
                     qwq[j][k]=max(qwq[j][i]*qwq[i][k],qwq[j][k]);
                 }
             }
         }
         bool flag=false;
             for(int i =  ; i < n; i++)
             {
                 if(qwq[i][i]>1.0)
                 {
                     flag=true;
                     break;
                 }
             }
             printf("Case %d: ",case1++);
             if(flag){
                 printf("Yes\n");
             }
             else
             printf("No\n");
     }

     return ;
 }