hdu 1217 Arbitrage 两种算法AC代码,Floyd+Bellman-Ford 大水题一枚 注意是有向图~~

Arbitrage

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)

Total Submission(s): 4998    Accepted Submission(s): 2286

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

这题主要意思就是一种货币在交换一圈后,交换回来的钱大于原来的钱,,就输出YES,否则No。

话说,我整天做这种水题有意思吗。。。

最后对字符串的处理是用的map,把map映射成数字,对应成数组的下标。

两份代码都是一次AC,这题太水了。

Bellman-Ford算法:

#include <iostream>
#include <string>
#include <cstring>
#include <cstdio>
#include <map>
#define INF 100000000
#define MAX 40 

using namespace std ;

double dis[MAX],graph[MAX][MAX];
bool Bellman_Ford(int n)
{
	for(int i = 0 ; i <= n ; ++i)
	{
		dis[i] = 0.0;
	}
	dis[0] = 1 ;
	for(int i = 0 ; i < n-1 ; ++i)
	{
		for(int j = 0 ; j < n ; ++j)
		{
			for(int k = 0 ; k < n ; ++k)
			{
				if(graph[k][j] > 0.000001)
				{
					if(dis[j] < dis[k]*graph[k][j])
					{
						dis[j] = dis[k]*graph[k][j] ;
					}
				}
			}
		}
	}
	for(int i = 0 ; i < n ; ++i)
	{
		for(int j = 0 ; j < n ; ++j)
		{
			if(dis[i] < dis[j]*graph[j][i])	//只要有一个存在即可。
			{
				return true ;
			}
		}
	}
	return false ;
}

int main()
{
	int n , m , c = 1 ;
	double rate ;
	map<string,int> search;
	string nameA,nameB,temp ;
	while(cin>>n && n)
	{
		for(int i = 0 ; i < n ; ++i)
		{
			cin>>temp ;
			search.insert(pair<string,int>(temp,i));
		}
		cin>>m;
		memset(graph,0,sizeof(graph)) ;
		for(int j = 0 ; j < m ; ++j)
		{
			cin>>nameA>>rate>>nameB;
			int x = search[nameA] , y = search[nameB] ;
			graph[x][y] = rate ;
		}
		if(Bellman_Ford(n))
		{
			printf("Case %d: Yes\n",c++);
		}
		else
		{
			printf("Case %d: No\n",c++);
		}
		search.clear() ;
	}
	return 0 ;
}

Floyd算法:

<pre name="code" class="cpp">#include <iostream>
#include <string>
#include <cstring>
#include <cstdio>
#include <map>
#define INF 100000000
#define MAX 40 

using namespace std ;

double graph[MAX][MAX];
bool Floyd(int n)
{
	for(int k = 0 ; k < n ; ++k)
	{
		for(int i = 0 ; i < n ; ++i)
		{
			for(int j = 0 ; j < n ; ++j)
			{
				if(graph[i][j] < graph[i][k]*graph[k][j])
					graph[i][j] = graph[i][k]*graph[k][j] ;
			}
		}
	}
	for(int i = 0 ; i < n ; ++i)
	{
		if(graph[i][i]>1)
		{
			return true ;
		}
	}
	return false ;
}

int main()
{
	int n , m , c = 1 ;
	double rate ;
	map<string,int> search;
	string nameA,nameB,temp ;
	while(cin>>n && n)
	{
		memset(graph,0,sizeof(graph)) ;
		for(int i = 0 ; i < n ; ++i)
		{
			cin>>temp ;
			search.insert(pair<string,int>(temp,i));
			graph[i][i] = 1 ;
		}
		cin>>m;
		for(int j = 0 ; j < m ; ++j)
		{
			cin>>nameA>>rate>>nameB;
			int x = search[nameA] , y = search[nameB] ;
			graph[x][y] = rate ;
		}
		if(Floyd(n))
		{
			printf("Case %d: Yes\n",c++);
		}
		else
		{
			printf("Case %d: No\n",c++);
		}
		search.clear() ;
	}
	return 0 ;
}

与君共勉。

时间: 2024-11-16 19:58:40

hdu 1217 Arbitrage 两种算法AC代码,Floyd+Bellman-Ford 大水题一枚 注意是有向图~~的相关文章

hdu 1162 Eddy&#39;s picture 最小生成树入门题 Prim+Kruskal两种算法AC

Eddy's picture Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 7428    Accepted Submission(s): 3770 Problem Description Eddy begins to like painting pictures recently ,he is sure of himself to

hdu 1874 畅通工程续 两种算法AC Floyd+Bellman-Ford算法 又是一波水题~~

畅通工程续 Time Limit: 3000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 31655    Accepted Submission(s): 11564 Problem Description 某省自从实行了很多年的畅通工程计划后,终于修建了很多路.不过路多了也不好,每次要从一个城镇到另一个城镇时,都有许多种道路方案可以选择,而某些方案要比另一些方案行

hdu 1863 畅通工程 最小生成树模板入门题 prim+kruskal两种算法AC。

畅通工程 Time Limit: 1000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 18866    Accepted Submission(s): 8012 Problem Description 省政府"畅通工程"的目标是使全省任何两个村庄间都可以实现公路交通(但不一定有直接的公路相连,只要能间接通过公路可达即可).经过调查评估,得到的统计表中列出

hdu2082 找单词 母函数+完全背包两种算法AC。。数据较水

找单词 Time Limit: 1000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 4615    Accepted Submission(s): 3304 Problem Description 假设有x1个字母A, x2个字母B,..... x26个字母Z,同时假设字母A的价值为1,字母B的价值为2,..... 字母Z的价值为26.那么,对于给定的字母,可以找

最小生成树的两种算法:Prim和Kruskal算法

越来越明白了一个道理:你写不出代码的原因只有一个,那就是你没有彻底理解这个算法的思想!! 以前写过最小生成树,但是,水了几道题后,过了一段时间,就会忘却,一点也写不出来了.也许原因只有一个,那就是我没有彻底理解这两种算法. 主题: 其实,求最小生成树有两个要点,一个是权值最小,还有一个就是这个图必须是树.而Prim和Kruskal的不同之处在于两者选择的变量不同,Prim选择的是始终保持权值最小,然后逐个加点构建一棵树.而Kruskal则是始终保证是一棵树(虽然构建过程中不一定是真正的树,但并查

hdu 1217 Arbitrage (spfa算法)

题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=1217 题目大意:通过货币的转换,来判断是否获利,如果获利则输出Yes,否则输出No. 这里介绍一个STL中的map容器去处理数据,map<string,int>V,M; 现在我目前的理解是将字符串转换成数字,然后就是根据spfa的模板找最短路了..哇哈哈( ⊙o⊙ )哇 1 #include <iostream> 2 #include <cstdio> 3 #include

[ACM] hdu 1217 Arbitrage (bellman_ford最短路,判断是否有正权回路或Floyed)

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

HDU 1217 Arbitrage 【最短路,map+spfa】

Arbitrage Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 6985    Accepted Submission(s): 3212 Problem Description Arbitrage is the use of discrepancies in currency exchange rates to transform

hdu 1217 Arbitrage Floyd||SPFA

转载请注明出处:http://acm.hdu.edu.cn/showproblem.php?pid=1217 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