399 除法求值

题目描述：
给出方程式 A / B = k, 其中 A 和 B 均为用字符串表示的变量， k 是一个浮点型数字。根据已知方程式求解问题，并返回计算结果。如果结果不存在，则返回 -1.0。
输入总是有效的。你可以假设除法运算中不会出现除数为 0 的情况，且不存在任何矛盾的结果。

示例 1：
输入：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 ]

示例 2：
输入：equations = [[“a”,“b”],[“b”,“c”],[“bc”,“cd”]], values = [1.5,2.5,5.0], queries = [[“a”,“c”],[“c”,“b”],[“bc”,“cd”],[“cd”,“bc”]]
输出：[3.75000,0.40000,5.00000,0.20000]

示例 3：
输入：equations = [[“a”,“b”]], values = [0.5], queries = [[“a”,“b”],[“b”,“a”],[“a”,“c”],[“x”,“y”]]
输出：[0.50000,2.00000,-1.00000,-1.00000]

提示：
1 <= equations.length <= 20
equations[i].length == 2
1 <= equations[i][0].length, equations[i][1].length <= 5
values.length == equations.length
0.0 < values[i] <= 20.0
1 <= queries.length <= 20
queries[i].length == 2
1 <= queries[i][0].length, queries[i][1].length <= 5
equations[i][0], equations[i][1], queries[i][0], queries[i][1] 由小写英文字母与数字组成

方法1：
主要思路：解题汇总
（1）先根据给定的除法关系，建立两个给定的字符串之间的映射关系，建立总的映射图unordered_map<string,vector<pair<string,double>>> mp;比如，a/b=2,同时需要建立b/a=0.5的关系；
（2）然后求解给定的询问两个字符串的关系时，先找一下mp中是否有给定的字符串，若是没有，则依旧是-1.0；
（3）若是有，则需要使用深度搜索，在建立的图中去找给定两个字符串之间的关系是否存在，若存在，则计算结果，若不存在，则依旧为-1.0；

class Solution {
public:
    void dfs(unordered_map<string,vector<pair<string,double>>>& mp,string cur,unordered_set<string>&st,vector<double>&path,bool&get_res,string& dst){
        if(get_res){//已经找到了结果，直接返回
            return;
        }
        for(auto& it:mp[cur]){//遍历当前给定字符串的可以相邻的字符串
            if(it.first==dst){//若相邻的字符串是需要找到目标字符串，则标记，并返回
                path.push_back(it.second);
                get_res=true;
                return;
            }
            //若当前字符串的相邻字符串没有访问过，且在mp中存在，则接着递归
            if(st.count(it.first)==0&&mp.count(it.first)!=0){
                st.insert(it.first);//标识访问过该字符串
                path.push_back(it.second);//存储关系数字
                dfs(mp,it.first,st,path,get_res,dst);//递归
                if(get_res){//提前终止
                    return;
                }
                //复原
                st.erase(it.first);
                path.pop_back();
            }
        }
    }
    vector<double> calcEquation(vector<vector<string>>& equations, vector<double>& values, vector<vector<string>>& queries) {
        unordered_map<string,vector<pair<string,double>>> mp;
        for(int i=0;i<equations.size();++i){//使用给定的字符串之间的关系，建立图
            mp[equations[i][0]].push_back({equations[i][1],values[i]});
            mp[equations[i][1]].push_back({equations[i][0],1.0/values[i]});
        }
        vector<double> res(queries.size(),-1.0);//初始化查询的结果
        for(int i=0;i<queries.size();++i){//遍历各个查询
            if(mp.count(queries[i][0])&&mp.count(queries[i][1])){//判断当前询问的两个字符串是否合理
                unordered_set<string> st;//标识查询过的字符串
                st.insert(queries[i][0]);
                vector<double> path;//存储各个字符串之间的关系获得数字结果
                bool get_res=false;//标识是否最后找到给定的询问的结果
                dfs(mp,queries[i][0],st,path,get_res,queries[i][1]);//深度搜索
                if(get_res){//若找到了当前询问的结果
                    double tmp=1.0;//计算这个过程中的各个中间结果的成绩
                    for(auto& p:path){
                        tmp*=p;
                    }
                    res[i]=tmp;//存入当前结果
                }
            }
        }
        return res;
    }
};