Merge branch 'master' of https://github.com/azl397985856/leetcode

Author: robot

problems/236.lowest-common-ancestor-of-a-binary-tree.md

@@ -137,8 +137,10 @@ class Solution:
 
 **复杂度分析**
 
+令 h 为树的高度。
+
 - 时间复杂度：$O(N)$
-- 空间复杂度：$O(N)$
+- 空间复杂度：$O(h)$
 
 ## 扩展
 

problems/516.longest-palindromic-subsequence.md

@@ -85,6 +85,11 @@ base case 就是一个字符（轴对称点是本身）
 
 ## 代码
 
+代码支持：JS，Python3
+
+
+JS Code：
+
 ```js
 /*
  * @lc app=leetcode id=516 lang=javascript
@@ -116,10 +121,44 @@ var longestPalindromeSubseq = function (s) {
 };
 ```
 
+Python3 Code（记忆化递归）：
+
+```py
+class Solution:
+    def longestPalindromeSubseq(self, s: str) -> int:
+        @cache
+        def dp(l,r):
+            if l >= r: return int(l == r)
+            if s[l] == s[r]: 
+                return 2 + dp(l+1,r-1)
+            return max(dp(l+1, r), dp(l, r-1))
+        return dp(0, len(s)-1)
+```
+
+Python3 Code(普通 dp)
+
+```py
+class Solution:
+    def longestPalindromeSubseq(self, s: str) -> int:
+        n = len(s)
+        dp = [[0]*n for _ in range(n)]
+
+        for i in range(n-1, -1, -1):
+            for j in range(i, n):
+                if i == j:
+                    dp[i][j] = 1
+                elif s[i] == s[j]:
+                    dp[i][j] = dp[i+1][j-1]+2
+                else:
+                    dp[i][j] = max(dp[i+1][j], dp[i][j-1])
+        return dp[0][-1]
+        
+ ```
+
 **复杂度分析**
 
-- 时间复杂度：$O(N^2)$
-- 空间复杂度：$O(N^2)$
+- 时间复杂度：枚举所有的状态需要 n^2 时间，状态转移需要常数的时间，因此总的时间复杂度为 $O(n^2)$
+- 空间复杂度：我们使用二维 dp 存储所有状态，因此空间复杂度为 $O(n^2)$
 
 ## 相关题目
 

problems/785.is-graph-bipartite.md

@@ -109,7 +109,7 @@ class Solution:
 令 v 和 e 为图中的顶点数和边数。
 
 - 时间复杂度：$O(v+e)$
-- 空间复杂度：$O(v+e)$
+- 空间复杂度：$O(v)$, stack depth = $O(v)$, and colors array.length = $O(v)$
 
 
 如上代码并不优雅，之所以这么写只是为了体现和 886 题一致性。一个更加优雅的方式是不建立 grid，而是利用题目给的 graph（邻接矩阵）。
@@ -137,6 +137,10 @@ class Solution:
 
 ### 代码
 
+代码支持：Python3，Java
+
+Python3 Code：
+
 ```py
 class UF:
     def __init__(self, n):
@@ -163,13 +167,85 @@ class Solution:
         return True
 ```
 
+Java Code：
+
+```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
 
 ## 相关问题
 

thinkings/tree.md

@@ -580,7 +580,7 @@ class Solution:
             # 叶子节点
             if cur and not cur.left and not cur.right:
                 if remain == cur.val:
-                    res.append((path + [cur.val]).copy())
+                    nodes.append((path + [cur.val]).copy())
                 return
             # 选择
             path.append(cur.val)