除法求值

给你一个变量对数组 equations 和一个实数值数组 values 作为已知条件，其中 equations[i] = [Ai, Bi] 和 values[i] 共同表示等式 Ai / Bi = values[i] 。每个 Ai 或 Bi 是一个表示单个变量的字符串。

另有一些以数组 queries 表示的问题，其中 queries[j] = [Cj, Dj] 表示第 j 个问题，请你根据已知条件找出 Cj / Dj = ? 的结果作为答案。

返回 所有问题的答案 。如果存在某个无法确定的答案，则用 -1.0 替代这个答案。如果问题中出现了给定的已知条件中没有出现的字符串，也需要用 -1.0 替代这个答案。

注意：输入总是有效的。你可以假设除法运算中不会出现除数为 0 的情况，且不存在任何矛盾的结果。

输入：equations = [[“a”,“b”],[“b”,“c”]], values = [2.0,3.0], queries = [[“a”,“c”],[“b”,“a”],[“a”,“e”],[“a”,“a”],[“x”,“x”]]
输出：[6.00000,0.50000,-1.00000,1.00000,-1.00000]
解释：
条件：a / b = 2.0, b / c = 3.0
问题：a / c = ?, b / a = ?, a / e = ?, a / a = ?, x / x = ?
结果：[6.0, 0.5, -1.0, 1.0, -1.0 ]

思路：并查集

如果a/b = 2. 把a和b相连接，权值是2。如果求a/c，经过的路径是a-b-c，权值是2和3，把路径上的权值相乘，就是结果。

class Solution {
public:
    //全局变量2个
    vector<double> res;
    // Nofand的意思应该是有很多条路径可以到达终点，只要有一条到了，就标记为false，停止继续访问
    bool Nofand;

    void dfs(unordered_map< string , vector<pair<string,double>> >& g, unordered_map<string,int>& visit,string val, const string& target, const double& path){
        //如果节点已经相连接，那没 必要再dfs搜索了，直接返回
        if( Nofand == false )
            return;
        
        if( val == target){
            Nofand = false;
            res.push_back(path);
            return;
        }

        for(int j = 0;j<g[val].size(); ++j){
            //检查与val相连接的点，是否已经访问过了。没访问过继续dfs
            if(visit[ g[val][j].first ] == 0 ){
                visit[ g[val][j].first ] = 1;
                dfs( g,visit, g[val][j].first, target, path*g[val][j].second );
                visit[ g[val][j].first ] = 0;
            }
        }
    }

    vector<double> calcEquation(vector<vector<string>>& equations, vector<double>& values, vector<vector<string>>& queries) {

        //string - string(double)  a连接b(b带上权值)
        unordered_map< string , vector<pair<string,double>> > g;
        unordered_map<string,int> visit;

        //构建无向图，a-b的value是3 的话 ，b-a是3的倒数
        for(int i =0;i<equations.size();++i){
            g[equations[i][0]].push_back( make_pair(equations[i][1], values[i] ) );
            g[equations[i][1]].push_back( make_pair(equations[i][0], 1.0/values[i] ) );
        }

        //遍历queries，对每一组进行dfs计算结果。
        //如果相连接，就把 路径上的权值相乘就是结果

        for(int i =0; i<queries.size();++i){
            
            //如果queries[0]是不存在的，直接出结果：-1
            if( g.find(queries[i][0]) == g.end() ){
                res.push_back(-1.0);
                continue;
            }
                
            //设置一个全局变量，如果进行dfs后，queries[0]到不了queries[1]，Nofind = true;
            Nofand = true;

            visit[queries[i][0]]=1;
            dfs(g,visit,queries[i][0],queries[i][1],1);
            visit[queries[i][0]]=0;

            if( Nofand )
            res.push_back(-1.0);
        }

        return res;
    }
};