fd

Author: dingjikerbo

leetcode/solution/src/EvaluateDivision.java

@@ -9,43 +9,59 @@
 public class EvaluateDivision {
 
     public double[] calcEquation(String[][] equations, double[] values, String[][] queries) {
-        HashMap<String, HashMap<String, Double>> valueMap = new HashMap<>();
-
+        HashMap<String, HashMap<String, Double>> table = new HashMap<>();
         for (int i = 0; i < equations.length; i++) {
-            String[] equation = equations[i];
-            HashMap<String, Double> map = valueMap.computeIfAbsent(equation[0], k -> new HashMap<>());
-            map.put(equation[1], values[i]);
-            map = valueMap.computeIfAbsent(equation[1], k -> new HashMap<>());
-            map.put(equation[0], 1 / values[i]);
+            add(table, equations[i], values[i]);
         }
-
         double[] result = new double[queries.length];
+        HashSet<String> visited = new HashSet<>();
         for (int i = 0; i < queries.length; i++) {
-            double[] value = new double[] {1.0};
-            result[i] = dfs(valueMap, queries[i][0], queries[i][1], new HashSet<>(), value) ? value[0] : -1.0;
+            visited.clear();
+            result[i] = calc(table, visited, queries[i][0], queries[i][1]);
         }
         return result;
     }
 
-    private boolean dfs(HashMap<String, HashMap<String, Double>> map, String start, String end, HashSet<String> set, double[] value) {
-        if (!map.containsKey(start) || !map.containsKey(end) || set.contains(start)) {
-            return false;
+    private double calc(HashMap<String, HashMap<String, Double>> table, HashSet<String> visited, String a, String b) {
+        HashMap<String, Double> map = table.get(a);
+        if (map == null) {
+            return -1.0;
         }
-        if (start.equals(end)) {
-            return true;
+        if (a.equals(b)) {
+            return 1.0;
         }
-        set.add(start);
-        HashMap<String, Double> valueMap = map.get(start);
-        boolean flag = false;
-        for (Map.Entry<String, Double> entry : valueMap.entrySet()) {
-            value[0] *= entry.getValue();
-            if (dfs(map, entry.getKey(), end, set, value)) {
-                flag = true;
-                break;
+        for (Map.Entry<String, Double> entry : map.entrySet()) {
+            String key = entry.getKey();
+            Double value = entry.getValue();
+
+            if (visited.contains(key)) {
+                continue;
+            }
+
+            visited.add(key);
+
+            double t = calc(table, visited, key, b);
+            if (t != -1.0) {
+                return value * t;
             }
-            value[0] /= entry.getValue();
+
+            visited.remove(key);
+        }
+        return -1.0;
+    }
+
+    private void add(HashMap<String, HashMap<String, Double>> table, String[] equation, double value) {
+        HashMap<String, Double> map0 = table.get(equation[0]);
+        HashMap<String, Double> map1 = table.get(equation[1]);
+        if (map0 == null) {
+            map0 = new HashMap<>();
+            table.put(equation[0], map0);
+        }
+        if (map1 == null) {
+            map1 = new HashMap<>();
+            table.put(equation[1], map1);
         }
-        set.remove(start);
-        return flag;
+        map0.put(equation[1], value);
+        map1.put(equation[0], 1 / value);
     }
 }

leetcode/src/Main.java

@@ -2,21 +2,75 @@
 
 public class Main {
 
-    public static int numDecodings(String s) {
-        int len = s.length();
-        int[] dp = new int[len];
-        for (int i = 0; i < len; i++) {
-            if (s.charAt(i) != '0') {
-                dp[i] += i > 0 ? dp[i - 1] : 1;
+    public static class Solution {
+        public double[] calcEquation(String[][] equations, double[] values, String[][] queries) {
+            HashMap<String, HashMap<String, Double>> table = new HashMap<>();
+            for (int i = 0; i < equations.length; i++) {
+                add(table, equations[i], values[i]);
             }
-            if (i > 0 && (s.charAt(i - 1) == '1' || (s.charAt(i - 1) == '2' && s.charAt(i) <= '6'))) {
-                dp[i] += i > 1 ? dp[i - 2] : 1;
+            double[] result = new double[queries.length];
+            HashSet<String> visited = new HashSet<>();
+            for (int i = 0; i < queries.length; i++) {
+                visited.clear();
+                result[i] = calc(table, visited, queries[i][0], queries[i][1]);
             }
+            return result;
+        }
+
+        private double calc(HashMap<String, HashMap<String, Double>> table, HashSet<String> visited, String a, String b) {
+            HashMap<String, Double> map = table.get(a);
+            if (map == null) {
+                return -1.0;
+            }
+            if (a.equals(b)) {
+                return 1.0;
+            }
+            for (Map.Entry<String, Double> entry : map.entrySet()) {
+                String key = entry.getKey();
+                Double value = entry.getValue();
+
+                if (visited.contains(key)) {
+                    continue;
+                }
+
+                visited.add(key);
+
+                double t = calc(table, visited, key, b);
+                if (t != -1.0) {
+                    return value * t;
+                }
+
+                visited.remove(key);
+            }
+            return -1.0;
+        }
+
+        private void add(HashMap<String, HashMap<String, Double>> table, String[] equation, double value) {
+            HashMap<String, Double> map0 = table.get(equation[0]);
+            HashMap<String, Double> map1 = table.get(equation[1]);
+            if (map0 == null) {
+                map0 = new HashMap<>();
+                table.put(equation[0], map0);
+            }
+            if (map1 == null) {
+                map1 = new HashMap<>();
+                table.put(equation[1], map1);
+            }
+            map0.put(equation[1], value);
+            map1.put(equation[0], 1 / value);
         }
-        return dp[len - 1];
     }
 
+
     public static void main(String[] args) {
-        System.out.println(numDecodings("226"));
+        Solution s = new Solution();
+        double[] res = s.calcEquation(new String[][]{
+                {"a", "b"}, {"b", "c"}
+        }, new double[]{2.0, 3.0}, new String[][]{
+                {"a", "c"}, {"b", "a"}, {"a", "e"}, {"a", "a"}, {"x", "x"}
+        });
+        for (double v : res) {
+            System.out.println(v);
+        }
     }
 }