題目描述

給出方程式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]
  由小寫英文字母與數字組成

來源：力扣（LeetCode）
連結：https://leetcode-cn.com/problems/evaluate-division

思路解析

深度優先搜尋（DFS）

1. unordered_map<string, unordered_map<string, double>> graph 表示圖，可以通過訪問graph['a']['b']得到\(a/b\)的結果（如果存在）。
2. unordered_set<string> visited 表示已經訪問過的節點。
3. 若要計算\(a / b\)：
   • 查詢是否存在graph['a']['b']，若存在，直接返回結果；
   • 若不存在graph['a']['b']，則查詢graph['a']中存在哪些節點，比如存在'c', 'd'...，則分別查詢graph['c']['b']，graph['d']['b']
   • 倘若從graph['c']['b']中找到了結果，記為t，則返回t * graph['a']['c']
   • 若都沒有找到結果，返回-1。

程式碼實現

class Solution {
private:
    unordered_map<string, unordered_map<string, double>> graph;
    double dfs(string src, string dst, unordered_set<string> visited) {
        if(graph[src].count(dst))
            return graph[src][dst];
        for(const auto subequation : graph[src]) {
            if(visited.count(subequation.first))
                continue;
            visited.insert(subequation.first);
            double t = dfs(subequation.first, dst, visited);
            if(t > 0)
                return t * subequation.second;
        }
        return -1;
    }
public:
    vector<double> calcEquation(vector<vector<string>>& equations, vector<double>& values, vector<vector<string>>& queries) {
        for(int i = 0; i < equations.size(); i++) {
            auto e = equations[i];
            graph[e[0]][e[1]] = values[i];
            graph[e[1]][e[0]] = 1.0 / values[i];
        }
        vector<double> result;
        for(auto q : queries) {
            unordered_set<string> visited;
            double res = dfs(q[0], q[1], visited);
            result.push_back(res);
        }
        return result;
    }
};