LeetCode #399 除法求值

399. 除法求值

给你一个变量对数组 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 的情况，且不存在任何矛盾的结果。

示例 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 <= Ai.length, Bi.length <= 5
• values.length == equations.length
• 0.0 < values[i] <= 20.0
• 1 <= queries.length <= 20
• queries[i].length == 2
• 1 <= Cj.length, Dj.length <= 5
• Ai, Bi, Cj, Dj 由小写英文字母与数字组成

搜就好了，刚开始让我整复杂了，最初的思路事判断计算每个字符串的权重，就例如a/b=2，假设a=1，可以计算b等于0.5，一次类推，最后就可以直接根据字符串求值了，但没考虑到可能两个字符串不是同一簇，结果还得判断一下，虽然也过了，但复杂的多

class Solution {
public:
    map<string,int> toint;
    int cnt = 1;
    vector<pair<int,double>> vec[30];
    
    double val[30] = {0};
    vector<double> calcEquation(vector<vector<string>>& equations, vector<double>& values, vector<vector<string>>& queries) {
        
        for(int i = 0;i < equations.size();i++){
            if(toint[equations[i][0]] == 0)  toint[equations[i][0]] = cnt++;
            if(toint[equations[i][1]] == 0)  toint[equations[i][1]] = cnt++;
        }
        for(int i = 0;i < equations.size();i++){
            vec[toint[equations[i][0]]].push_back({toint[equations[i][1]],values[i]});
            vec[toint[equations[i][1]]].push_back({toint[equations[i][0]],1/values[i]});
        }
        vector<double> out;
        for(int i = 0;i < queries.size();i++){
            if(toint[queries[i][0]] == 0 || toint[queries[i][1]] == 0) out.push_back(-1.0);
            else{
                if(queries[i][0] == queries[i][1]) out.push_back(1.0);
                else{
                    int x = toint[queries[i][0]], y = toint[queries[i][1]];
                    queue<pair<int,double>> que;
                    que.push({x,1});
                    int vis[30] = {0};
                    int flag = 0;
                    double temp = 1;
                    while(que.size() != 0){
                        pair<int,double> p = que.front();
                        que.pop();
                        int xx = p.first;
                        double sum = p.second;
                        if(vis[xx] == 1) continue;
                        if(xx == y){
                            flag = 1;
                            temp = sum;
                            break;
                        }
                        vis[xx] = 1;
                        for(int j = 0;j < vec[xx].size();j++){
                            int yy = vec[xx][j].first;
                            que.push({yy,sum * vec[xx][j].second});
                        }
                    }
                    if(flag == 1) out.push_back(temp);
                    else out.push_back(-1.0);
                }
            }
        }
        return out;

    }
};