货币套汇（图路径）【数据结构-深度优先搜索-回路】

这题感觉有点小难（估计还是我太菜

题目描述
套汇是指利用货币汇兑率的差异将一个单位的某种货币转换为大于一个单位的同种货币。例如，假定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

思路就是先将输入转化为邻接矩阵（构造函数做的事情），然后在对每一个顶点进行深度优先搜索的的时候加入一个road数组，储存经过的路径，如果路上的其中的某个顶点与起点有路径，则说明形成了回路，那么此时判断这个回路上所有的点乘积是否大于一即可。
注意，需要对每个顶点的每个road上的每个点，都需要判断其与顶点间是否形成了回路，若形成则计算乘积。

#include <iostream>

using namespace std;

int findIndex(string huobi[],int length,string a){
    for(int i=0;i<length;i++){
        if(huobi[i]==a){
            return i;
        }
    }
    return -1;
}
class Map{
    int len; //顶点数
    int *v;  //访问标识数组
    double **Matrix; //邻接矩阵
    int num;
    int *road;
    string *huobi;
public:
    Map(){
        //创建图时根据输入的信息把邻接矩阵输入好
        cin>>len;
        num=0;
        road=new int[len];
        v=new int[len];
        for(int i=0;i<len;i++){
            v[i]=0;
            road[i]=0;
        }

        Matrix=new double*[len];
        for(int i=0;i<len;i++)
            Matrix[i]=new double[len];
        int num;
        cin>>num;
        huobi=new string[len];
        for(int i=0;i<len;i++){
            for(int j=0;j<len;j++){
                Matrix[i][j]=0;
                if(i==j)Matrix[i][j]=1;
            }
        }
        for(int i=0;i<len;i++){
            cin>>huobi[i];
        }
        for(int i=0;i<num/len;i++){
            for(int j=0;j<len;j++){
                string huobi1,huobi2;
                double huilv0;
                cin>>huobi1>>huilv0>>huobi2;
                int index1=findIndex(huobi,len,huobi1);
                int index2=findIndex(huobi,len,huobi2);
                Matrix[index1][index2]=huilv0;
            }
        }
        /*for(int i=0;i<len;i++){
            for(int j=0;j<len;j++){
                cout<<Matrix[i][j]<<" ";
            }
            cout<<endl;
        }*/
    }


    void dfs(int k){
        //cout<<k<<" ";
        v[k]=1;
        road[num]=k;
        num++;
        for(int i=0;i<len;i++){
            if(v[i]==0&&Matrix[k][i]!=0){
                dfs(i);
            }
        }

    }



    void DFSTraverse(){
        for(int i=0;i<len;i++){
            //对所有顶点进行循环
            num=0;
            dfs(i);
            for(int k=1;k<num;k++){
                //k代表的是从起点往下走k个点
                if(Matrix[road[k]][i]!=0){
                    //然后判断从第k个点到起点是否有路，如果有路就代表形成了回环
                    //因为road[k]是从起点走到第k个点了，只需要和起点有路说明形成了回路
                    float result=1;
                    int j;
                    for(j=0;j<k;j++){
                        result*=Matrix[road[j]][road[j+1]];
                        //接下来从起点乘到最后一个点
                    }
                        result*=Matrix[road[j]][road[0]];
                        //最后再从最后一个点回到原点，将其乘积乘起来
                    if(result>1){
                        cout<< "YES"<<endl;
                        return;
                    }
                }
            }


            for(int i=0;i<len;i++){
                v[i]=0;
                road[i]=0;
            }
        }
        cout<<"NO"<<endl;
        return;
    }


};




int main()
{
    int t;
    cin>>t;
    while(t--){

        Map map;
        map.DFSTraverse();
    }
    return 0;
}