fd

Author: dingjikerbo

solution/src/main/java/com/inuker/solution/NumberOfConnectedComponents.java

@@ -1,7 +1,9 @@
 package com.inuker.solution;
 
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Set;
 
 /**
  * Created by dingjikerbo on 17/1/2.
@@ -35,7 +37,6 @@ private int find(int[] nums, int i) {
     /**
      * DFS法
      */
-    // 8ms
     public int countComponents2(int n, int[][] edges) {
         List<Integer>[] graph = new ArrayList[n];
         for (int i = 0; i < n; i++) {
@@ -45,22 +46,21 @@ public int countComponents2(int n, int[][] edges) {
             graph[edge[0]].add(edge[1]);
             graph[edge[1]].add(edge[0]);
         }
-        boolean[] visited = new boolean[n];
+        Set<Integer> visited = new HashSet<>();
         int count = 0;
         for (int i = 0; i < n; i++) {
-            if (!visited[i]) {
-                dfs(graph, i, visited);
+            if (!visited.contains(i)) {
                 count++;
+                dfs(graph, i, visited);
             }
         }
         return count;
     }
 
-    private void dfs(List<Integer>[] graph, int i, boolean[] visited) {
-        if (visited[i]) {
+    private void dfs(List<Integer>[] graph, int i, Set<Integer> visited) {
+        if (!visited.add(i)) {
             return;
         }
-        visited[i] = true;
         for (Integer k : graph[i]) {
             dfs(graph, k, visited);
         }

solution/src/main/java/com/inuker/solution/RedundantConnection.java

@@ -10,6 +10,7 @@
 public class RedundantConnection {
     /**
      * 思路很简单，发现第一个联通的边时就是多余的
+     * 时间复杂度O(n)，空间O(n)
      */
     public int[] findRedundantConnection(int[][] edges) {
         int[] arr = new int[2001];

test/src/main/java/com/inuker/test/Test2.java

@@ -11,6 +11,7 @@
 import java.util.Map;
 import java.util.PriorityQueue;
 import java.util.Queue;
+import java.util.Set;
 import java.util.TreeMap;
 
 /**
@@ -19,44 +20,32 @@
 
 public class Test2 {
 
-    public double[] calcEquation(String[][] equations, double[] values, String[][] queries) {
-        HashMap<String, HashMap<String, Double>> valueMap = 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]);
+    public int countComponents2(int n, int[][] edges) {
+        List<Integer>[] graph = new ArrayList[n];
+        for (int i = 0; i < n; i++) {
+            graph[i] = new ArrayList<>();
         }
-
-        double[] result = new double[queries.length];
-        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;
+        for (int[] edge : edges) {
+            graph[edge[0]].add(edge[1]);
+            graph[edge[1]].add(edge[0]);
+        }
+        Set<Integer> visited = new HashSet<>();
+        int count = 0;
+        for (int i = 0; i < n; i++) {
+            if (!visited.contains(i)) {
+                count++;
+                dfs(graph, i, visited);
+            }
         }
-        return result;
+        return count;
     }
 
-    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;
-        }
-        if (start.equals(end)) {
-            return true;
+    private void dfs(List<Integer>[] graph, int i, Set<Integer> visited) {
+        if (!visited.add(i)) {
+            return;
         }
-        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;
-            }
-            value[0] /= entry.getValue();
+        for (Integer k : graph[i]) {
+            dfs(graph, k, visited);
         }
-        set.remove(start);
-        return flag;
     }
 }