POJ2240——Bellman_ford——Arbitrage

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 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

Source

Ulm Local 1996

大意：套利，形成一个环，不断利滚利，与currency exchange 不同的是它是随意进去一种钱，共1unit,如果这种钱循环之后大于1unit的话就返回true，ballen_ford其实就是找最小的正权回路，即if判断的那个，如果整个循环下来是亏得话，即不收敛，那么说明返回false，如果经过n-1次循环每次都是盈利，即只要有一种盈利，那个环就一直盈利，应为其他的钱都是可以相互转换的，那么返回true。就是ballen_ford的最短路径思想，松弛n-1次，如果存在不收敛的端点，那么就是不成功的。

ballen_ford算法

#include<cstdio>
#include<cstring>
using namespace std;
int N,M,count = 1;
double d[300];
struct edge{
    int v;
    int u;
    double rate;
}edge[3000];

bool  bellman_ford (int s)
{
    for(int i = 0; i <= N; i++)
     d[i] = 0;
     d[s] = 1.0;
     double temp = 1.0;
    for(int i = 1; i <= N; i++){
            bool flag = 1;
            for(int j = 0; j < M;j++){
                    if(d[edge[j].v] < d[edge[j].u]*edge[j].rate){
                            flag = 0;
                      d[edge[j].v] = d[edge[j].u]*edge[j].rate;
                    }
                if(d[s] > temp)
                    return true;
                }
           }
        return false ;
}
int main()
{
   char temp[300][300],temp1[300],temp2[300];
   while(~scanf("%d",&N)&&N){
        getchar();
   for(int i = 0; i < N ; i++)
    scanf("%s",temp[i]);
   scanf("%d",&M);
   for(int i = 0; i < M;i++){
    scanf("%s%lf%s",temp1,&edge[i].rate,temp2);
   for(int j = 0; j < N;j++){
        if(strcmp(temp[j],temp1)==0)
            edge[i].u = j;

        if(strcmp(temp[j],temp2)==0)
            edge[i].v = j;
      }
   }
   int flag1 = 0;
    for(int i = 0 ; i < N ; i++){
            if(bellman_ford(i)){
                    printf("Case %d: Yes\n",count);
                   flag1 = 1;
                   count++;
                   break;
            }
    }
   if(flag1 == 0) {printf("Case %d: No\n",count);
   count++;
    }
   }
   return 0;
}

floyed算法相当于ballen_ford函数里面不返回数，也不处理‘1’，让他三重循环（n)不断更新，然后在主函数里判断（i,i)点是否满足，网上拉来一段代码，原博文请看这里

#include <iostream>
#include<cstdio>
#include<cstring>
using namespace std;
#define maxn 1010
double edge[maxn][maxn];
char moneyname[40][40];
int n,m;
void floyd()
{
    for(int k=1;k<=n;k++)
    {
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=n;j++)
            {
                if(edge[i][j]<edge[i][k]*edge[k][j])
                {
                    edge[i][j]=edge[i][k]*edge[k][j];
                }
            }
        }
    }
}
int main()
{
    int count=1;
    while(scanf("%d",&n)!=EOF)
    {
        memset(edge,0,sizeof(edge));
        if(n==0)
        {
            break;
        }
        for(int i=1;i<=n;i++)
        {
            scanf("%s",moneyname[i]);
        }
        char first[40],last[40];
        double rate;
        int f,l;
        scanf("%d",&m);
        for(int i=1;i<=m;i++)
        {
            scanf("%s%lf%s",first,&rate,last);
            for(int j=1;j<=n;j++)
            {
                if(strcmp(moneyname[j],first)==0)
                {
                    f=j;
                }
                if(strcmp(moneyname[j],last)==0)
                {
                    l=j;
                }
            }
            edge[f][l]=rate;
        }
        printf("Case %d: ",count++);
        floyd();
        for(int i=1;i<=n;i++)
        {
            if(edge[i][i]>1.0)
            {
                printf("Yes\n");
                break;
            }
            else
            {
                printf("No\n");
                break;
            }
        }
    }
    return 0;
}