货币套汇（图路径）-- 数据结构 (深搜+Floyd算法）

题目描述

套汇是指利用货币汇兑率的差异将一个单位的某种货币转换为大于一个单位的同种货币。
例如，假定1 美元可以买0.7 英镑，1 英镑可以买9.5法郎，1法郎可以买到0.16美元。通过货币兑换，一个商人可以从1美元开始买入，得到0.7×9.5×0.16=1.064美元，从而获得6.4%的利润。 给定n种货币c1 ,c2 ,… ,cn的有关兑换率，试设计一个有效算法，确定货币间是否存在套汇的可能性。


提示：判断图上是否出现正环,即环上所有的边相乘大于1

输入

第一行：测试数据组数

每组测试数据格式为：

第一行：正整数n (1< =n< =30)，正整数m，分别表示n种货币和m种不同的货币兑换率。

2~n+1行，n种货币的名称。

n+2~n+m+1行，每行有3 个数据项ci，rij 和cj ，表示货币ci 和cj的兑换率为 rij。

输出

对每组测试数据，如果存在套汇的可能则输出YES

如果不存在套汇的可能，则输出NO。

样例输入

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

样例输出

YES
NO

思路

这整一道题下来，首先最先的思路就是希望构造一个图，然后通过深度搜索DFS，将每一条边的权值都乘起来，最后再乘回终点与起点的权值，若大于1，则说明是一个正环，并且套汇成功，直接输出YES。

深搜

题解

#include <iostream>
#include<string>
using namespace std;

class Graph
{
	int vexnum;//顶点数
	int arcnum;//输入的边数
	bool *visit;//访问数组
	double **array;//邻接矩阵
	string *vex;//边
	int *road;//记录走过的路
	int num;
	void DFS(int v);
	int Index(string s)
	{
		for (int i = 0; i < vexnum; i++)
			if (vex[i] == s) return i;
		return -1;
	}
public:
	Graph();
	~Graph();
	void DFS_Traverse();
};

Graph::Graph()
{
	cin >> vexnum >> arcnum;
	vex = new string[vexnum];
	visit = new bool[vexnum];
	road = new int[vexnum];
	array = new double*[vexnum];
	for (int i = 0; i < vexnum; i++)
	{
		cin >> vex[i];
		array[i] = new double[vexnum];
		visit[i] = false;
		road[i] = 0;
		for (int j = 0; j < vexnum; j++)
			array[i][j] = 0;
	}
	for (int i = 0; i < arcnum; i++)
	{
		string str1, str2;
		double weight;
		cin >> str1 >> weight >> str2;
		int pos1 = Index(str1), pos2 = Index(str2);
		array[pos1][pos2] = weight;
	}
}

Graph::~Graph()
{
	delete[]vex;
	delete[]road;
	delete[]visit;
	for (int i = 0; i < vexnum; i++)
		delete array[i];
	delete array;
}

void Graph::DFS(int v)
{
	visit[v] = true;
	road[num++] = v;//记录每一条经过的边，以便后面的计算
	for (int i = 0; i < vexnum; i++)
	{
		if (visit[i] == 0 && array[v][i] != 0)//若无访问且有边相接，继续遍历
			DFS(i);
	}
}


void Graph::DFS_Traverse()
{
	for (int i = 0; i < vexnum; i++)//对每一个节点都进行一次遍历
	{
		num = 0;//定义为0
		DFS(i);
		for (int k = 1; k < num; k++)
		{
			if (array[road[k]][i] != 0) {//判断与起点是否构成环，若构成环则进行计算操作
				float result = 1;
				for (int j = 0; j < k; j++)
					result *= array[road[j]][road[j + 1]];//一直乘到最后一个点
				result *= array[road[k]][road[0]];//最后从最后一个点回到起点，构成一个环，将其乘起来
				//cout << result << endl;
				if (result > 1) {//套汇成功，存在正环
					cout << "YES\n";
					return;
				}
			}

		}
		for (int i = 0; i < vexnum; i++)//对visit数组重新初始化
		{
			visit[i] = false;
			road[i] = 0;
		}
	}
	cout << "NO\n";//没找到正环
}

int main()
{
	int t;
	cin >> t;
	while (t--)
	{
		Graph graph;
		graph.DFS_Traverse();
	}
	return 0;
}

Floyd算法

优化

后来这道题仔细想了想，最后发现，这种深度搜索的方法固然可以得出答案，但是若是点很多，遍历的顺序无法确定。举个例子，假设只存在一个正环，若遍历的点很多，可能要耗费很长的时间，最后遍历到那个环，最后输出yes，最后同样能得出正确答案，但是并不是最佳解法。

最后我想尝试用Floyd算法去解这道题试试看
如果用Floyd算法，这道题就变得简单起来，只要判断最后的对角线是否大于1，如果大于1就可以得到套汇成功

#include<iostream>
#include<string>
#include<map>
using namespace std;
#define MAX 30
double path[MAX][MAX];
map<string, int>ratemap;

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 (path[i][j] < path[i][k] * path[k][j])
					path[i][j] = path[i][k] * path[k][j];
	for (int i = 0; i < n; i++)
		if (path[i][i] > 1)
			return true;
	return false;
}


int main()
{
	int t;
	cin >> t;
	while (t--)
	{
		memset(path, 0, sizeof(path));
		int n, m;
		double rate;
		cin >> n >> m;
		string edge1, edge2, edge;
		for (int i = 0; i < n; i++)
		{
			cin >> edge;
			pair<string, int>a(edge, i);
			ratemap.insert(a);
			path[i][i] = 1;
		}
		for (int i = 0; i < m; i++)
		{
			cin >> edge1 >> rate >> edge2;
			path[ratemap[edge1]][ratemap[edge2]] = rate;
		}
		if (Floyd(n)) cout << "YES\n";
		else cout << "NO\n";
		ratemap.clear();
	}
	return 0;
}