399. 除法求值

要求：除法，输入：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]
法一：bfs

class Solution {
public:
    unordered_map<string, vector<pair<string, double>>> edges;
    unordered_set<string> nodes;
    double BFS(string start,string end) {
        if (nodes.find(start) == nodes.end() || nodes.find(end) == nodes.end())return (double)-1;
        queue<pair<string, double>> que;//BFS需要队列
        unordered_set<string> used;//记录遍历过的点
        que.push({ start,1 });//放入起始点
        used.insert(start);//记录
        while (!que.empty()) {
            string curNode = que.front().first;
            double curRes = que.front().second;
            if (curNode == end) return curRes;//找到直接返回
            que.pop();
            if (edges.find(curNode) == edges.end())continue;
            for (int i = 0; i < edges[curNode].size(); i++) {//遍历邻接点
                string newNode = edges[curNode][i].first;
                double newRes = curRes * edges[curNode][i].second;//计算下一个点的结果
                if (used.find(newNode) != used.end())continue;
                used.insert(newNode);//标记已使用
                que.push({ newNode,newRes });//入队继续遍历
            }
        }
        return (double)-1;//没找到返回-1
    }
    vector<double> calcEquation(vector<vector<string>>& equations, vector<double>& values, vector<vector<string>>& queries) {
        vector<double> res;
        for (int i = 0; i < equations.size(); i++) {//建图
            nodes.insert(equations[i][0]);
            nodes.insert(equations[i][1]);
            edges[equations[i][0]].push_back({ equations[i][1],values[i] });
            edges[equations[i][1]].push_back({ equations[i][0],1.0 / values[i] });
        }
        for (int i = 0; i < queries.size(); i++) {//对每个公式计算结果
            res.push_back(BFS(queries[i][0], queries[i][1]));
        }
        return res;
    }
};

法二：floyd算法求最短路径，本题显然最短路径唯一，对每个点k作中介三重循环更新i-k-j

class Solution {
public:
    vector<double> calcEquation(vector<vector<string>>& equations, vector<double>& values, vector<vector<string>>& queries) {
        int nvars = 0;
        unordered_map<string, int> variables;

        int n = equations.size();
        for (int i = 0; i < n; i++) {
            if (variables.find(equations[i][0]) == variables.end()) {
                variables[equations[i][0]] = nvars++;
            }
            if (variables.find(equations[i][1]) == variables.end()) {
                variables[equations[i][1]] = nvars++;
            }
        }
        vector<vector<double>> graph(nvars, vector<double>(nvars, -1.0));
        for (int i = 0; i < n; i++) {
            int va = variables[equations[i][0]], vb = variables[equations[i][1]];
            graph[va][vb] = values[i];
            graph[vb][va] = 1.0 / values[i];
        }

        for (int k = 0; k < nvars; k++) {
            for (int i = 0; i < nvars; i++) {
                for (int j = 0; j < nvars; j++) {
                    if (graph[i][k] > 0 && graph[k][j] > 0) {
                        graph[i][j] = graph[i][k] * graph[k][j];
                    }
                }
            }
        }

        vector<double> ret;
        for (const auto& q: queries) {
            double result = -1.0;
            if (variables.find(q[0]) != variables.end() && variables.find(q[1]) != variables.end()) {
                int ia = variables[q[0]], ib = variables[q[1]];
                if (graph[ia][ib] > 0) {
                    result = graph[ia][ib];
                }
            }
            ret.push_back(result);
        }
        return ret;
    }
};

法三带权并查集