Leetcode: Evaluate Division

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.

Graph, DFS

(1) Build the map, the key is dividend, the value is also a map whose key is divisor and value is its parameter. For example, a / b = 2.0, the map entry is <"a", <"b", 2.0>>. To make searching and calculation easier, we also put b / a = 0.5 into the map.
(2) for each query, use DFS to search divisors recursively

 public class Solution {
     public double[] calcEquation(String[][] equations, double[] values, String[][] queries) {
         double[] res = new double[queries.length];
         HashMap<String, HashMap<String, Double>> map = new HashMap<String, HashMap<String, Double>>();
         for (int i=0; i<equations.length; i++) {
             String[] equation = equations[i];
             double value = values[i];
             if (!map.containsKey(equation[0])) {
                 map.put(equation[0], new HashMap<String, Double>());
                 map.get(equation[0]).put(equation[0], 1.0);
             }
             if (!map.containsKey(equation[1])) {
                 map.put(equation[1], new HashMap<String, Double>());
                 map.get(equation[1]).put(equation[1], 1.0);
             }
             map.get(equation[0]).put(equation[1], value);
             map.get(equation[1]).put(equation[0], 1/value);
         }

         for (int j=0; j<queries.length; j++) {
             res[j] = -1.0; //initialize
             dfs(map, queries[j][0], queries[j][1], new HashSet<String>(), res, j, 1.0);
         }
         return res;
     }

     public void dfs(HashMap<String, HashMap<String, Double>> map, String src, String dest, HashSet<String> visited, double[] res, int index, double pathVal) {
         if (!map.containsKey(src) || !map.containsKey(dest)) {
             res[index] = -1.0;
             return;
         }
         if (visited.contains(src)) return;
         HashMap<String, Double> srcNb = map.get(src);
         if (srcNb.containsKey(dest)) {
             res[index] = pathVal * srcNb.get(dest);
             return;
         }
         visited.add(src);
         for (Map.Entry<String, Double> entry : srcNb.entrySet()) {
             String neibor = entry.getKey();
             dfs(map, neibor, dest, visited, res, index, pathVal*entry.getValue());
         }
         visited.remove(src);
     }
 }