Update 785.is-graph-bipartite.md

Author: taojin1992

problems/785.is-graph-bipartite.md

@@ -163,13 +163,83 @@ class Solution:
         return True
 ```
 
+```java
+// weighted quick-union with path compression
+class Solution {
+    class UF {
+	    int numOfUnions; // number of unions
+	    int[] parent;
+	    int[] size; 
+	
+	    UF(int numOfElements) {
+		    numOfUnions = numOfElements;
+		    parent = new int[numOfElements];
+		    size = new int[numOfElements];
+		    for (int i = 0; i < numOfElements; i++) {
+			    parent[i] = i;
+			    size[i] = 1;
+		    }
+	    }
+
+	    // find the head/representative of x
+	    int find(int x) {
+		    while (x != parent[x]) {
+			    parent[x] = parent[parent[x]]; 
+			    x = parent[x]; 	
+		    }
+		    return x;
+	    }
+
+	    void union(int p, int q) {
+		    int headOfP = find(p);
+		    int headOfQ = find(q);
+		    if (headOfP == headOfQ) {
+			    return;
+		    }
+		    // connect the small tree to the larger tree
+		    if (size[headOfP] < size[headOfQ]) {
+			    parent[headOfP] = headOfQ; // set headOfP's parent to be headOfQ 
+			    size[headOfQ] += size[headOfP];
+		    } else {
+			    parent[headOfQ] = headOfP;
+			    size[headOfP] += size[headOfQ];
+		    }
+		    numOfUnions -= 1;
+	    }
+
+	    boolean connected(int p, int q) {
+		    return find(p) == find(q);
+	    }
+    }
+
+    public boolean isBipartite(int[][] graph) {
+        int n = graph.length;
+        UF unionfind = new UF(n);
+        // i is what node each adjacent list is for
+        for (int i = 0; i < n; i++) {
+            // i's neighbors
+            for (int neighbor : graph[i]) {
+                // i should not be in the union of its neighbors
+                if (unionfind.connected(i, neighbor)) {
+                    return false;
+                }
+                // add into unions
+                unionfind.union(graph[i][0], neighbor);
+            }
+        }
+        
+        return true;
+    }
+    
+```
+
 
 **复杂度分析**
 
 令 v 和 e 为图中的顶点数和边数。
 
-- 时间复杂度：$O(v+e)$
-- 空间复杂度：$O(v+e)$
+- 时间复杂度：$O(v+e)$, using weighted quick-union with path compression, where union, find and connected are $O(1)$, constructing unions takes $O(v)$
+- 空间复杂度：$O(v)$ for auxiliary union-find space int[] parent, int[] space
 
 ## 相关问题