leetcode399- Evaluate Division- medium

Equations are given in the format A / B = k, where A and B are variables represented as strings, and k is a real number (floating point number). Given some queries, return the answers. If the answer does not exist, return -1.0.

Example:
Given a / b = 2.0, b / c = 3.0. 
queries are: a / c = ?, b / a = ?, a / e = ?, a / a = ?, x / x = ? . 
return [6.0, 0.5, -1.0, 1.0, -1.0 ].

The input is: vector<pair<string, string>> equations, vector<double>& values, vector<pair<string, string>> queries, where equations.size() == values.size(), and the values are positive. This represents the equations. Return vector<double>.

According to the example above:

equations = [ ["a", "b"], ["b", "c"] ],
values = [2.0, 3.0],
queries = [ ["a", "c"], ["b", "a"], ["a", "e"], ["a", "a"], ["x", "x"] ]. 

The input is always valid. You may assume that evaluating the queries will result in no division by zero and there is no contradiction.

数据结构：用Map<String, Map<String, double>>来存储dividend- divisor- quotient关系。每读到一个信息的时候需要加入4行数据：dividend-divisor-quotient, dividend-dividend-1, divisor-dividend-1/quotient, divisor-divisor-1

算法：DFS。这个宏观大问题拆解成小问题时，变的其实是被除数，不变的是最终的除数，试着找一条链条最后导向最终除数。函数头private double dfs(Map<String, Map<String, Double>> map, String dividend, String finalDivisor, Set<String> visited) 。利用map，找到dividend / finalDivisor的答案并返回，同时找的过程中利用visited避免循环查找导致stackOverFlow。

1.如果直接没有dividend，肯定失败。

2.在dividend对应的keySet()也就是divisor里循环。

　　2.1如果找到finalDivisor了，整个dfs都结束了，一层层返回

　　2.2退而求其次把这个divisor当成下一层的dividend递归，试着递归到链条传到finalDivisor。

　　2.3如果这个divisor已经被visited了，肯定没必要再找了，continue

　　2.4递归一下(上下状态修改)

　　2.5递归成功的话帮助传上去

3.全循环完了也没有在中间return回合格结果的话，那肯定失败了，传回失败标志。

细节：1.建关系映射的时候要记得加入自除和反除信息，一共四条。2.要使用Set visited记录找过的不可能的那些被除数避免重复工作，有时候重复还会危险到循环查找导致stackOverFlow。set的操作对象都是divisor。因为你接下来要做的工作是把divisor当成新的被除数有没有希望，所以你要做的是1.检查这个divisor被做过没有，2.改变状态记录Set里的divisor状态 3.递归divisor。这些作用目标应该有一致性，而不是去操作当前的dividend。

实现：

class Solution {
    public double[] calcEquation(String[][] equations, double[] values, String[][] queries) {
        Map<String, Map<String, Double>> map = new HashMap<>();
        for (int i = 0; i < equations.length; i++) {
            String dividend = equations[i][0];
            String divisor = equations[i][1];
            double quotient = values[i];
            if (!map.containsKey(dividend)) {
                map.put(dividend, new HashMap<String, Double>());
            }
            if (!map.containsKey(divisor)) {
                map.put(divisor, new HashMap<String, Double>());
            }
            // 有一个自除千万记得加！
            map.get(dividend).put(dividend, 1.0);
            map.get(divisor).put(divisor, 1.0);
            // 有一个反除千万记得加！
            map.get(dividend).put(divisor, quotient);
            map.get(divisor).put(dividend, 1 / quotient);
        }

        double[] result = new double[queries.length];
        for (int i = 0; i < queries.length; i++) {
            result[i] = dfs(map, queries[i][0], queries[i][1], new HashSet<String>());
        }
        return result;
    }

    private double dfs(Map<String, Map<String, Double>> map, String dividend, String finalDivisor, Set<String> visited) {
        if (!map.containsKey(dividend)) {
            return -1.0;
        }
        for (String divisor : map.get(dividend).keySet()) {
            double quotient = map.get(dividend).get(divisor);
            if (divisor.equals(finalDivisor)) {
                return quotient;
            }
            // 注意用set。避免同一个被除数被反复检查除以finalDivisor导致stackoverflow
            if (visited.contains(divisor)) {
                continue;
            }
            visited.add(divisor);
            double deepQ = dfs(map, divisor, finalDivisor, visited);
            visited.remove(divisor);
            if (deepQ != -1.0) {
                return quotient * deepQ;
            }
        }
        return -1.0;
    }
}