feat: add solutions to lc problem: No.1676

No.1676.Lowest Common Ancestor of a Binary Tree IV

Author: yanglbme

solution/1600-1699/1668.Maximum Repeating Substring/README.md

@@ -50,9 +50,9 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-**方法一：暴力枚举**
+**方法一：直接枚举**
 
-直接从大到小枚举 `word` 的重复次数，判断 `word` 重复该次数后是否是 `sequence` 的子串即可。
+注意到字符串长度不超过 $100$，我们直接从大到小枚举 `word` 的重复次数 $k$，判断 `word` 重复该次数后是否是 `sequence` 的子串，是则直接返回当前的重复次数 $k$。
 
 时间复杂度为 $O(n^2)$，其中 $n$ 为 `sequence` 的长度。
 
@@ -65,11 +65,9 @@
 ```python
 class Solution:
     def maxRepeating(self, sequence: str, word: str) -> int:
-        x = len(sequence) // len(word)
-        for k in range(x, 0, -1):
+        for k in range(len(sequence) // len(word), -1, -1):
             if word * k in sequence:
                 return k
-        return 0
 ```
 
 ### **Java**
@@ -79,8 +77,7 @@ class Solution:
 ```java
 class Solution {
     public int maxRepeating(String sequence, String word) {
-        int x = sequence.length() / word.length();
-        for (int k = x; k > 0; --k) {
+        for (int k = sequence.length() / word.length(); k > 0; --k) {
             if (sequence.contains(word.repeat(k))) {
                 return k;
             }
@@ -100,6 +97,7 @@ public:
         string t = word;
         int x = sequence.size() / word.size();
         for (int k = 1; k <= x; ++k) {
+            // C++ 这里从小到大枚举重复值
             if (sequence.find(t) != string::npos) {
                 ans = k;
             }
@@ -114,8 +112,7 @@ public:
 
 ```go
 func maxRepeating(sequence string, word string) int {
-	x := len(sequence) / len(word)
-	for k := x; k > 0; k-- {
+	for k := len(sequence) / len(word); k > 0; k-- {
 		if strings.Contains(sequence, strings.Repeat(word, k)) {
 			return k
 		}

solution/1600-1699/1668.Maximum Repeating Substring/README_EN.md

@@ -51,20 +51,17 @@
 ```python
 class Solution:
     def maxRepeating(self, sequence: str, word: str) -> int:
-        x = len(sequence) // len(word)
-        for k in range(x, 0, -1):
+        for k in range(len(sequence) // len(word), -1, -1):
             if word * k in sequence:
                 return k
-        return 0
 ```
 
 ### **Java**
 
 ```java
 class Solution {
     public int maxRepeating(String sequence, String word) {
-        int x = sequence.length() / word.length();
-        for (int k = x; k > 0; --k) {
+        for (int k = sequence.length() / word.length(); k > 0; --k) {
             if (sequence.contains(word.repeat(k))) {
                 return k;
             }
@@ -98,8 +95,7 @@ public:
 
 ```go
 func maxRepeating(sequence string, word string) int {
-	x := len(sequence) / len(word)
-	for k := x; k > 0; k-- {
+	for k := len(sequence) / len(word); k > 0; k-- {
 		if strings.Contains(sequence, strings.Repeat(word, k)) {
 			return k
 		}

solution/1600-1699/1668.Maximum Repeating Substring/Solution.go

@@ -1,6 +1,5 @@
 func maxRepeating(sequence string, word string) int {
-	x := len(sequence) / len(word)
-	for k := x; k > 0; k-- {
+	for k := len(sequence) / len(word); k > 0; k-- {
 		if strings.Contains(sequence, strings.Repeat(word, k)) {
 			return k
 		}

solution/1600-1699/1668.Maximum Repeating Substring/Solution.java

@@ -1,7 +1,6 @@
 class Solution {
     public int maxRepeating(String sequence, String word) {
-        int x = sequence.length() / word.length();
-        for (int k = x; k > 0; --k) {
+        for (int k = sequence.length() / word.length(); k > 0; --k) {
             if (sequence.contains(word.repeat(k))) {
                 return k;
             }

solution/1600-1699/1668.Maximum Repeating Substring/Solution.py

@@ -1,7 +1,5 @@
 class Solution:
     def maxRepeating(self, sequence: str, word: str) -> int:
-        x = len(sequence) // len(word)
-        for k in range(x, 0, -1):
+        for k in range(len(sequence) // len(word), -1, -1):
             if word * k in sequence:
                 return k
-        return 0

solution/1600-1699/1675.Minimize Deviation in Array/README.md

@@ -12,7 +12,6 @@
 
 <ul>
 	<li>如果元素是<strong> 偶数</strong> ，<strong>除以</strong> <code>2</code>
-
     <ul>
     	<li>例如，如果数组是 <code>[1,2,3,4]</code> ，那么你可以对最后一个元素执行此操作，使其变成 <code>[1,2,3,<strong>2</strong>]</code></li>
     </ul>
@@ -22,7 +21,6 @@
     	<li>例如，如果数组是 <code>[1,2,3,4]</code> ，那么你可以对第一个元素执行此操作，使其变成 <code>[<strong>2</strong>,2,3,4]</code></li>
     </ul>
     </li>
-
 </ul>
 
 <p>数组的 <strong>偏移量</strong> 是数组中任意两个元素之间的 <strong>最大差值</strong> 。</p>

solution/1600-1699/1675.Minimize Deviation in Array/README_EN.md

@@ -10,7 +10,6 @@
 
 <ul>
 	<li>If the element is <strong>even</strong>, <strong>divide</strong> it by <code>2</code>.
-
     <ul>
     	<li>For example, if the array is <code>[1,2,3,4]</code>, then you can do this operation on the last element, and the array will be <code>[1,2,3,<u>2</u>].</code></li>
     </ul>
@@ -20,7 +19,6 @@
     	<li>For example, if the array is <code>[1,2,3,4]</code>, then you can do this operation on the first element, and the array will be <code>[<u>2</u>,2,3,4].</code></li>
     </ul>
     </li>
-
 </ul>
 
 <p>The <strong>deviation</strong> of the array is the <strong>maximum difference</strong> between any two elements in the array.</p>

solution/1600-1699/1676.Lowest Common Ancestor of a Binary Tree IV/README.md

@@ -147,21 +147,53 @@ class Solution {
  */
 class Solution {
 public:
-    unordered_set<int> s;
-
     TreeNode* lowestCommonAncestor(TreeNode* root, vector<TreeNode*>& nodes) {
+        unordered_set<int> s;
         for (auto node : nodes) s.insert(node->val);
+        function<TreeNode*(TreeNode*)> dfs = [&](TreeNode* root) -> TreeNode* {
+            if (!root || s.count(root->val)) return root;
+            auto left = dfs(root->left);
+            auto right = dfs(root->right);
+            if (!left) return right;
+            if (!right) return left;
+            return root;
+        };
         return dfs(root);
     }
+};
+```
 
-    TreeNode* dfs(TreeNode* root) {
-        if (!root || s.count(root->val)) return root;
-        auto left = dfs(root->left);
-        auto right = dfs(root->right);
-        if (!left) return right;
-        if (!right) return left;
-        return root;
+### **JavaScript**
+
+```js
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {TreeNode[]} nodes
+ * @return {TreeNode}
+ */
+var lowestCommonAncestor = function (root, nodes) {
+    const s = new Set();
+    for (const node of nodes) {
+        s.add(node.val);
+    }
+    function dfs(root) {
+        if (!root || s.has(root.val)) {
+            return root;
+        }
+        const [left, right] = [dfs(root.left), dfs(root.right)];
+        if (left && right) {
+            return root;
+        }
+        return left || right;
     }
+    return dfs(root);
 };
 ```
 

solution/1600-1699/1676.Lowest Common Ancestor of a Binary Tree IV/README_EN.md

@@ -131,21 +131,53 @@ class Solution {
  */
 class Solution {
 public:
-    unordered_set<int> s;
-
     TreeNode* lowestCommonAncestor(TreeNode* root, vector<TreeNode*>& nodes) {
+        unordered_set<int> s;
         for (auto node : nodes) s.insert(node->val);
+        function<TreeNode*(TreeNode*)> dfs = [&](TreeNode* root) -> TreeNode* {
+            if (!root || s.count(root->val)) return root;
+            auto left = dfs(root->left);
+            auto right = dfs(root->right);
+            if (!left) return right;
+            if (!right) return left;
+            return root;
+        };
         return dfs(root);
     }
+};
+```
 
-    TreeNode* dfs(TreeNode* root) {
-        if (!root || s.count(root->val)) return root;
-        auto left = dfs(root->left);
-        auto right = dfs(root->right);
-        if (!left) return right;
-        if (!right) return left;
-        return root;
+### **JavaScript**
+
+```js
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {TreeNode[]} nodes
+ * @return {TreeNode}
+ */
+var lowestCommonAncestor = function (root, nodes) {
+    const s = new Set();
+    for (const node of nodes) {
+        s.add(node.val);
+    }
+    function dfs(root) {
+        if (!root || s.has(root.val)) {
+            return root;
+        }
+        const [left, right] = [dfs(root.left), dfs(root.right)];
+        if (left && right) {
+            return root;
+        }
+        return left || right;
     }
+    return dfs(root);
 };
 ```
 

solution/1600-1699/1676.Lowest Common Ancestor of a Binary Tree IV/Solution.cpp

@@ -11,19 +11,17 @@
  */
 class Solution {
 public:
-    unordered_set<int> s;
-
     TreeNode* lowestCommonAncestor(TreeNode* root, vector<TreeNode*>& nodes) {
+        unordered_set<int> s;
         for (auto node : nodes) s.insert(node->val);
+        function<TreeNode*(TreeNode*)> dfs = [&](TreeNode* root) -> TreeNode* {
+            if (!root || s.count(root->val)) return root;
+            auto left = dfs(root->left);
+            auto right = dfs(root->right);
+            if (!left) return right;
+            if (!right) return left;
+            return root;
+        };
         return dfs(root);
     }
-
-    TreeNode* dfs(TreeNode* root) {
-        if (!root || s.count(root->val)) return root;
-        auto left = dfs(root->left);
-        auto right = dfs(root->right);
-        if (!left) return right;
-        if (!right) return left;
-        return root;
-    }
 };