feat: add solutions to lc problem: No.1650 (doocs#2357)

No.1650.Lowest Common Ancestor of a Binary Tree III

Author: yanglbme

.github/workflows/deploy.yml

@@ -54,18 +54,18 @@ jobs:
           github_token: ${{ secrets.GITHUB_TOKEN }}
           publish_dir: ./site
 
-      # - name: Sync to gitee.com
-      #   uses: wearerequired/git-mirror-action@master
-      #   env:
-      #       SSH_PRIVATE_KEY: ${{ secrets.RSA_PRIVATE_KEY }}
-      #   with:
-      #       source-repo: git@github.com:doocs/leetcode.git
-      #       destination-repo: git@gitee.com:Doocs/leetcode.git
+      - name: Sync to gitee.com
+        uses: wearerequired/git-mirror-action@master
+        env:
+            SSH_PRIVATE_KEY: ${{ secrets.RSA_PRIVATE_KEY }}
+        with:
+            source-repo: git@github.com:doocs/leetcode.git
+            destination-repo: git@gitee.com:Doocs/leetcode.git
 
-      # - name: Build Gitee Pages
-      #   uses: yanglbme/gitee-pages-action@main
-      #   with:
-      #       gitee-username: yanglbme
-      #       gitee-password: ${{ secrets.GITEE_PASSWORD }}
-      #       gitee-repo: doocs/leetcode
-      #       branch: gh-pages
+      - name: Build Gitee Pages
+        uses: yanglbme/gitee-pages-action@main
+        with:
+            gitee-username: yanglbme
+            gitee-password: ${{ secrets.GITEE_PASSWORD }}
+            gitee-repo: doocs/leetcode
+            branch: gh-pages

solution/1600-1699/1650.Lowest Common Ancestor of a Binary Tree III/README.md

@@ -56,7 +56,154 @@
 
 ## 解法
 
-### 方法一
+### 方法一：哈希表
+
+我们用一个哈希表 $vis$ 记录从节点 $p$ 开始到根节点的路径上的所有节点，接下来从节点 $q$ 开始往根节点方向遍历，如果遇到一个节点存在于哈希表 $vis$ 中，那么该节点就是 $p$ 和 $q$ 的最近公共祖先节点，直接返回即可。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 是二叉树的节点数。
+
+<!-- tabs:start -->
+
+```python
+"""
+# Definition for a Node.
+class Node:
+    def __init__(self, val):
+        self.val = val
+        self.left = None
+        self.right = None
+        self.parent = None
+"""
+
+
+class Solution:
+    def lowestCommonAncestor(self, p: "Node", q: "Node") -> "Node":
+        vis = set()
+        node = p
+        while node:
+            vis.add(node)
+            node = node.parent
+        node = q
+        while node not in vis:
+            node = node.parent
+        return node
+```
+
+```java
+/*
+// Definition for a Node.
+class Node {
+    public int val;
+    public Node left;
+    public Node right;
+    public Node parent;
+};
+*/
+
+class Solution {
+    public Node lowestCommonAncestor(Node p, Node q) {
+        Set<Node> vis = new HashSet<>();
+        for (Node node = p; node != null; node = node.parent) {
+            vis.add(node);
+        }
+        for (Node node = q;; node = node.parent) {
+            if (!vis.add(node)) {
+                return node;
+            }
+        }
+    }
+}
+```
+
+```cpp
+/*
+// Definition for a Node.
+class Node {
+public:
+    int val;
+    Node* left;
+    Node* right;
+    Node* parent;
+};
+*/
+
+class Solution {
+public:
+    Node* lowestCommonAncestor(Node* p, Node* q) {
+        unordered_set<Node*> vis;
+        for (Node* node = p; node; node = node->parent) {
+            vis.insert(node);
+        }
+        for (Node* node = q;; node = node->parent) {
+            if (vis.count(node)) {
+                return node;
+            }
+        }
+    }
+};
+```
+
+```go
+/**
+ * Definition for Node.
+ * type Node struct {
+ *     Val int
+ *     Left *Node
+ *     Right *Node
+ *     Parent *Node
+ * }
+ */
+
+func lowestCommonAncestor(p *Node, q *Node) *Node {
+	vis := map[*Node]bool{}
+	for node := p; node != nil; node = node.Parent {
+		vis[node] = true
+	}
+	for node := q; ; node = node.Parent {
+		if vis[node] {
+			return node
+		}
+	}
+}
+```
+
+```ts
+/**
+ * Definition for a binary tree node.
+ * class Node {
+ *     val: number
+ *     left: Node | null
+ *     right: Node | null
+ *     parent: Node | null
+ *     constructor(val?: number, left?: Node | null, right?: Node | null, parent?: Node | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.left = (left===undefined ? null : left)
+ *         this.right = (right===undefined ? null : right)
+ *         this.parent = (parent===undefined ? null : parent)
+ *     }
+ * }
+ */
+
+function lowestCommonAncestor(p: Node | null, q: Node | null): Node | null {
+    const vis: Set<Node> = new Set();
+    for (let node = p; node; node = node.parent) {
+        vis.add(node);
+    }
+    for (let node = q; ; node = node.parent) {
+        if (vis.has(node)) {
+            return node;
+        }
+    }
+}
+```
+
+<!-- tabs:end -->
+
+### 方法二：双指针
+
+我们可以用两个指针 $a$ 和 $b$ 分别指向节点 $p$ 和 $q$，然后分别往根节点方向遍历，当 $a$ 和 $b$ 相遇时，就是 $p$ 和 $q$ 的最近公共祖先节点。否则，如果指针 $a$ 遍历到了根节点，那么我们就让它指向节点 $q$，指针 $b$ 同理。这样，当两个指针相遇时，就是 $p$ 和 $q$ 的最近公共祖先节点。
+
+时间复杂度 $O(n)$，其中 $n$ 是二叉树的节点数。空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 
@@ -159,6 +306,33 @@ func lowestCommonAncestor(p *Node, q *Node) *Node {
 }
 ```
 
+```ts
+/**
+ * Definition for a binary tree node.
+ * class Node {
+ *     val: number
+ *     left: Node | null
+ *     right: Node | null
+ *     parent: Node | null
+ *     constructor(val?: number, left?: Node | null, right?: Node | null, parent?: Node | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.left = (left===undefined ? null : left)
+ *         this.right = (right===undefined ? null : right)
+ *         this.parent = (parent===undefined ? null : parent)
+ *     }
+ * }
+ */
+
+function lowestCommonAncestor(p: Node | null, q: Node | null): Node | null {
+    let [a, b] = [p, q];
+    while (a != b) {
+        a = a.parent ?? q;
+        b = b.parent ?? p;
+    }
+    return a;
+}
+```
+
 <!-- tabs:end -->
 
 <!-- end -->