547_Friend_Circles

Author: qiyuangong

README.md

@@ -153,7 +153,7 @@ Also, there are open source implementations for basic data structs and algorithm
 | 482 | [License Key Formatting](https://leetcode.com/problems/license-key-formatting/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/482_License_Key_Formatting.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/482_License_Key_Formatting.java) | String processing, lower and len % K, O(n) and O(n) |
 | 538 | [Convert BST to Greater Tree](https://leetcode.com/problems/convert-bst-to-greater-tree/description/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/538_Convert_BST_to_Greater_Tree.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/538_Convert_BST_to_Greater_Tree.java) | Right first DFS with a variable recording sum of node.val and right.val. 1. Recursive.<br>2. Stack 3. Reverse Morris In-order Traversal |
 | 543 | [Diameter of Binary Tree](https://leetcode.com/problems/diameter-of-binary-tree/description/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/543_Diameter_of_Binary_Tree.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/543_Diameter_of_Binary_Tree.java) | DFS with O(1) for max answer |
-| 547 | [Friend Circles](https://leetcode.com/problems/friend-circles/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/547_Friend_Circles.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/547_Friend_Circles.java) | 1. DFS, O(n^2) and O(1)<br>2. BFS, O(n^2) and O(1)<br>3. Union-find,  |
+| 547 | [Friend Circles](https://leetcode.com/problems/friend-circles/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/547_Friend_Circles.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/547_Friend_Circles.java) | 1. DFS, O(n^2) and O(1)<br>2. BFS, O(n^2) and O(1)<br>3. Union-find, O(n^2) and O(n)|
 | 557 | [Reverse Words in a String III](https://leetcode.com/problems/reverse-words-in-a-string-iii/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/557_Reverse_Words_in_a_String_III.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/557_Reverse_Words_in_a_String_III.java) | String handle: Split with space than reverse word, O(n) and O(n). Better solution is that reverse can be O(1) space in array. |
 | 560 | [Subarray Sum Equals K](https://leetcode.com/problems/subarray-sum-equals-k/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/560_Subarray_Sum_Equals_K.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/560_Subarray_Sum_Equals_K.java) | Note that there are n^2 possible pairs, so the key point is accelerate computation for sum and reduce unnecessary pair. 1. Cummulative sum, O(n^2) and O(1)/O(n)<br>2. Add sum into hash, check if sum - k is in hash, O(n) and O(n) |
 | 572 | [Subtree of Another Tree](https://leetcode.com/problems/subtree-of-another-tree/description/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/572_Subtree_of_Another_Tree.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/572_Subtree_of_Another_Tree.java) | 1. Tree traverse and compare<br>2. Tree to string and compare |

java/547_Friend_Circles.java

@@ -0,0 +1,76 @@
+public class Solution {
+    public void dfs(int[][] M, int[] visited, int i) {
+        for (int j = 0; j < M.length; j++) {
+            if (M[i][j] == 1 && visited[j] == 0) {
+                visited[j] = 1;
+                dfs(M, visited, j);
+            }
+        }
+    }
+    public int findCircleNum(int[][] M) {
+        // DFS
+        int[] visited = new int[M.length];
+        int count = 0;
+        for (int i = 0; i < M.length; i++) {
+            if (visited[i] == 0) {
+                dfs(M, visited, i);
+                count++;
+            }
+        }
+        return count;
+    }
+
+    /*public int findCircleNum(int[][] M) {
+        // BFS
+        int[] visited = new int[M.length];
+        int count = 0;
+        Queue < Integer > queue = new LinkedList < > ();
+        for (int i = 0; i < M.length; i++) {
+            if (visited[i] == 0) {
+                queue.add(i);
+                while (!queue.isEmpty()) {
+                    int s = queue.remove();
+                    visited[s] = 1;
+                    for (int j = 0; j < M.length; j++) {
+                        if (M[s][j] == 1 && visited[j] == 0)
+                            queue.add(j);
+                    }
+                }
+                count++;
+            }
+        }
+        return count;
+    }*/
+
+    /*
+    // Union find
+    int find(int parent[], int i) {
+        if (parent[i] == -1)
+            return i;
+        return find(parent, parent[i]);
+    }
+
+    void union(int parent[], int x, int y) {
+        int xset = find(parent, x);
+        int yset = find(parent, y);
+        if (xset != yset)
+            parent[xset] = yset;
+    }
+    public int findCircleNum(int[][] M) {
+        int[] parent = new int[M.length];
+        Arrays.fill(parent, -1);
+        for (int i = 0; i < M.length; i++) {
+            for (int j = 0; j < M.length; j++) {
+                if (M[i][j] == 1 && i != j) {
+                    union(parent, i, j);
+                }
+            }
+        }
+        int count = 0;
+        for (int i = 0; i < parent.length; i++) {
+            if (parent[i] == -1)
+                count++;
+        }
+        return count;
+    }*/
+}

python/547_Friend_Circles.py

@@ -0,0 +1,92 @@
+class Solution(object):
+    def findCircleNum(self, M):
+        """
+        :type M: List[List[int]]
+        :rtype: int
+        """
+        # because
+        visited = [0] * len(M)
+        count = 0
+        for i in range(len(M)):
+            if visited[i] == 0:
+                self.dfs(M, visited, i)
+                count += 1
+        return count
+
+    def dfs(self, M, visited, i):
+        for j in range(len(M)):
+            if M[i][j] == 1 and visited[j] == 0:
+                visited[j] = 1
+                self.dfs(M, visited, j)
+
+    # def findCircleNum(self, M):
+    #     # BFS
+    #     visited = [0] * len(M)
+    #     count = 0
+    #     queue = []
+    #     for i in range(len(M)):
+    #         if visited[i] == 0:
+    #             queue.append(i)
+    #             while queue:
+    #                 curr = queue.pop(0)
+    #                 visited[curr] = 1
+    #                 for j in range(len(M)):
+    #                     if M[curr][j] == 1 and visited[j] == 0:
+    #                         queue.append(j)
+    #             count += 1
+    #     return count
+
+#     def findCircleNum(self, M):
+#         # Union Find
+#         union = Union()
+#         for i in range(len(M)):
+#             union.add(i)
+#         for i in range(len(M)):
+#             for j in range(i + 1, len(M)):
+#                 if M[i][j] == 1:
+#                     union.union(i, j)
+#         return union.count
+
+# class Union(object):
+#     """
+#     weighted quick union find
+#     """
+#     def __init__(self):
+#         # both dic and list is fine
+#         self.id = {}
+#         self.sz = {}
+#         self.count = 0
+
+#     def count(self):
+#         return self.count
+
+#     def connected(self, p, q):
+#         return self.find(p) == self.find(q)
+
+#     def add(self, p):
+#         # init
+#         self.id[p] = p
+#         self.sz[p] = 1
+#         self.count += 1
+
+#     def find(self, p):
+#         """
+#         find root of p, and compress path
+#         """
+#         while p != self.id[p]:
+#             self.id[p] = self.id[self.id[p]]
+#             p = self.id[p]
+#         return p
+
+#     def union(self, p, q):
+#         """
+#         connect p and q
+#         """
+#         i, j = self.find(p), self.find(q)
+#         if i == j:
+#             return
+#         if self.sz[i] > self.sz[j]:
+#             i, j = j, i
+#         self.id[i] = j
+#         self.sz[j] += self.sz[i]
+#         self.count -= 1