feat: update solutions to lc problem: No.0654

No.0654.Maximum Binary Tree

Author: yanglbme

lcof2/剑指 Offer II 064. 神奇的字典/tmp.py

@@ -1,21 +1,19 @@
 class Codec:
     def encode(self, strs: List[str]) -> str:
-        """Encodes a list of strings to a single string.
-        """
+        """Encodes a list of strings to a single string."""
         ans = []
         for s in strs:
             ans.append('{:4}'.format(len(s)) + s)
         return ''.join(ans)
 
     def decode(self, s: str) -> List[str]:
-        """Decodes a single string to a list of strings.
-        """
+        """Decodes a single string to a list of strings."""
         ans = []
         i, n = 0, len(s)
         while i < n:
-            size = int(s[i: i + 4])
+            size = int(s[i : i + 4])
             i += 4
-            ans.append(s[i: i + size])
+            ans.append(s[i : i + size])
             i += size
         return ans
 

solution/0200-0299/0271.Encode and Decode Strings/Solution.py

@@ -98,7 +98,7 @@ ans not knows 6
 ans = 6 
 ```
 
-这里 $ans$ 认识 $3$，说明 $ans$ 不是名人（$0$ 不是名人），那么名人会是 $1$ 或者 $2$ 吗？不会！因为若 $1$ 或者 $2$ 是名人，那么 $0$ 应该认识 $1$ 或者 $2$ 才对，与前面的例子冲突。因此，我们可以直接将 $ans$ 更新为 $i$。
+这里 $ans$ 认识 $3$，说明 $ans$ 不是名人（即 $0$ 不是名人），那么名人会是 $1$ 或者 $2$ 吗？不会！因为若 $1$ 或者 $2$ 是名人，那么 $0$ 应该认识 $1$ 或者 $2$ 才对，与前面的例子冲突。因此，我们可以直接将 $ans$ 更新为 $i$。
 
 我们找出 $ans$ 之后，接下来再遍历一遍，判断 $ans$ 是否满足名人的条件。若不满足，返回 $-1$。
 

solution/0200-0299/0277.Find the Celebrity/README.md

@@ -2,6 +2,7 @@
 # return a bool, whether a knows b
 # def knows(a: int, b: int) -> bool:
 
+
 class Solution:
     def findCelebrity(self, n: int) -> int:
         ans = 0

solution/0200-0299/0277.Find the Celebrity/Solution.py

@@ -68,7 +68,7 @@
 
 同时遍历 $word$ 和 $abbr$，若 $abbr$ 遇到数字，则 $word$ 跳过对应数字长度的字符数。若数字为空，或者有前导零，则提前返回 false。
 
-时间复杂度 $O(m+n)$，空间复杂度 $O(1)$。其中 $m$ 是 $word$ 的长度，$n$ 是 $abbr$ 的长度。
+时间复杂度 $O(m+n)$，空间复杂度 $O(1)$。其中 $m$ 是 $word$ 的长度，而 $n$ 是 $abbr$ 的长度。
 
 <!-- tabs:start -->
 

solution/0400-0499/0408.Valid Word Abbreviation/README.md

@@ -11,7 +11,7 @@ def validWordAbbreviation(self, word: str, abbr: str) -> bool:
             k = j
             while k < n and abbr[k].isdigit():
                 k += 1
-            t = abbr[j: k]
+            t = abbr[j:k]
             if not t.isdigit() or t[0] == '0' or int(t) == 0:
                 return False
             i += int(t)

solution/0400-0499/0408.Valid Word Abbreviation/Solution.py

@@ -56,7 +56,11 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-先找到数组的最大元素所在的位置，作为根节点，然后递归左右两侧的子数组，构建左右子树。
+**方法一：递归**
+
+先找到数组 $nums$ 的最大元素所在的位置 $i$，将 $nums[i]$ 作为根节点，然后递归左右两侧的子数组，构建左右子树。
+
+时间复杂度 $O(n^2)$，空间复杂度 $O(n)$，其中 $n$ 是数组的长度。
 
 <!-- tabs:start -->
 
@@ -72,17 +76,18 @@
 #         self.left = left
 #         self.right = right
 class Solution:
-    def constructMaximumBinaryTree(self, nums: List[int]) -> TreeNode:
-        def inner(nums, l, r):
-            if l > r:
+    def constructMaximumBinaryTree(self, nums: List[int]) -> Optional[TreeNode]:
+        def dfs(nums):
+            if not nums:
                 return None
-            mx = l
-            for i in range(l + 1, r + 1):
-                if nums[mx] < nums[i]:
-                    mx = i
-            return TreeNode(nums[mx], inner(nums, l, mx - 1), inner(nums, mx + 1, r))
-
-        return inner(nums, 0, len(nums) - 1)
+            val = max(nums)
+            i = nums.index(val)
+            root = TreeNode(val)
+            root.left = dfs(nums[:i])
+            root.right = dfs(nums[i + 1:])
+            return root
+        
+        return dfs(nums)
 ```
 
 ### **Java**
@@ -106,21 +111,27 @@ class Solution:
  * }
  */
 class Solution {
+    private int[] nums;
+
     public TreeNode constructMaximumBinaryTree(int[] nums) {
-        return construct(nums, 0, nums.length - 1);
+        this.nums = nums;
+        return dfs(0, nums.length - 1);
     }
 
-    private TreeNode construct(int[] nums, int l, int r) {
+    private TreeNode dfs(int l, int r) {
         if (l > r) {
             return null;
         }
-        int mx = l;
-        for (int i = l + 1; i <= r; ++i) {
-            if (nums[mx] < nums[i]) {
-                mx = i;
+        int i = l;
+        for (int j = l; j <= r; ++j) {
+            if (nums[i] < nums[j]) {
+                i = j;
             }
         }
-        return new TreeNode(nums[mx], construct(nums, l, mx - 1), construct(nums, mx + 1, r));
+        TreeNode root = new TreeNode(nums[i]);
+        root.left = dfs(l, i - 1);
+        root.right = dfs(i + 1, r);
+        return root;
     }
 }
 ```
@@ -142,18 +153,20 @@ class Solution {
 class Solution {
 public:
     TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
-        return construct(nums, 0, nums.size() - 1);
+        return dfs(nums, 0, nums.size() - 1);
     }
 
-    TreeNode* construct(vector<int>& nums, int l, int r) {
+    TreeNode* dfs(vector<int>& nums, int l, int r) {
         if (l > r) return nullptr;
-        int mx = l;
-        for (int i = l + 1; i <= r; ++i) {
-            if (nums[mx] < nums[i]) mx = i;
+        int i = l;
+        for (int j = l; j <= r; ++j) {
+            if (nums[i] < nums[j]) {
+                i = j;
+            }
         }
-        TreeNode* root = new TreeNode(nums[mx]);
-        root->left = construct(nums, l, mx - 1);
-        root->right = construct(nums, mx + 1, r);
+        TreeNode* root = new TreeNode(nums[i]);
+        root->left = dfs(nums, l, i - 1);
+        root->right = dfs(nums, i + 1, r);
         return root;
     }
 };
@@ -171,24 +184,23 @@ public:
  * }
  */
 func constructMaximumBinaryTree(nums []int) *TreeNode {
-	return construct(nums, 0, len(nums)-1)
-}
-
-func construct(nums []int, l, r int) *TreeNode {
-	if l > r {
-		return nil
-	}
-	mx := l
-	for i := l + 1; i <= r; i++ {
-		if nums[mx] < nums[i] {
-			mx = i
-		}
-	}
-	return &TreeNode{
-		Val:   nums[mx],
-		Left:  construct(nums, l, mx-1),
-		Right: construct(nums, mx+1, r),
-	}
+    var dfs func(l, r int) *TreeNode
+    dfs = func(l, r int) *TreeNode {
+        if l > r {
+            return nil
+        }
+        i := l
+        for j := l; j <= r; j++ {
+            if nums[i] < nums[j] {
+                i = j
+            }
+        }
+        root := &TreeNode{Val: nums[i]}
+        root.Left = dfs(l, i - 1)
+        root.Right = dfs(i + 1, r)
+        return root
+    }
+    return dfs(0, len(nums)-1)
 }
 ```
 

solution/0600-0699/0654.Maximum Binary Tree/README.md

@@ -62,17 +62,18 @@
 #         self.left = left
 #         self.right = right
 class Solution:
-    def constructMaximumBinaryTree(self, nums: List[int]) -> TreeNode:
-        def inner(nums, l, r):
-            if l > r:
+    def constructMaximumBinaryTree(self, nums: List[int]) -> Optional[TreeNode]:
+        def dfs(nums):
+            if not nums:
                 return None
-            mx = l
-            for i in range(l + 1, r + 1):
-                if nums[mx] < nums[i]:
-                    mx = i
-            return TreeNode(nums[mx], inner(nums, l, mx - 1), inner(nums, mx + 1, r))
-
-        return inner(nums, 0, len(nums) - 1)
+            val = max(nums)
+            i = nums.index(val)
+            root = TreeNode(val)
+            root.left = dfs(nums[:i])
+            root.right = dfs(nums[i + 1:])
+            return root
+        
+        return dfs(nums)
 ```
 
 ### **Java**
@@ -94,21 +95,27 @@ class Solution:
  * }
  */
 class Solution {
+    private int[] nums;
+
     public TreeNode constructMaximumBinaryTree(int[] nums) {
-        return construct(nums, 0, nums.length - 1);
+        this.nums = nums;
+        return dfs(0, nums.length - 1);
     }
 
-    private TreeNode construct(int[] nums, int l, int r) {
+    private TreeNode dfs(int l, int r) {
         if (l > r) {
             return null;
         }
-        int mx = l;
-        for (int i = l + 1; i <= r; ++i) {
-            if (nums[mx] < nums[i]) {
-                mx = i;
+        int i = l;
+        for (int j = l; j <= r; ++j) {
+            if (nums[i] < nums[j]) {
+                i = j;
             }
         }
-        return new TreeNode(nums[mx], construct(nums, l, mx - 1), construct(nums, mx + 1, r));
+        TreeNode root = new TreeNode(nums[i]);
+        root.left = dfs(l, i - 1);
+        root.right = dfs(i + 1, r);
+        return root;
     }
 }
 ```
@@ -130,18 +137,20 @@ class Solution {
 class Solution {
 public:
     TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
-        return construct(nums, 0, nums.size() - 1);
+        return dfs(nums, 0, nums.size() - 1);
     }
 
-    TreeNode* construct(vector<int>& nums, int l, int r) {
+    TreeNode* dfs(vector<int>& nums, int l, int r) {
         if (l > r) return nullptr;
-        int mx = l;
-        for (int i = l + 1; i <= r; ++i) {
-            if (nums[mx] < nums[i]) mx = i;
+        int i = l;
+        for (int j = l; j <= r; ++j) {
+            if (nums[i] < nums[j]) {
+                i = j;
+            }
         }
-        TreeNode* root = new TreeNode(nums[mx]);
-        root->left = construct(nums, l, mx - 1);
-        root->right = construct(nums, mx + 1, r);
+        TreeNode* root = new TreeNode(nums[i]);
+        root->left = dfs(nums, l, i - 1);
+        root->right = dfs(nums, i + 1, r);
         return root;
     }
 };
@@ -159,24 +168,23 @@ public:
  * }
  */
 func constructMaximumBinaryTree(nums []int) *TreeNode {
-	return construct(nums, 0, len(nums)-1)
-}
-
-func construct(nums []int, l, r int) *TreeNode {
-	if l > r {
-		return nil
-	}
-	mx := l
-	for i := l + 1; i <= r; i++ {
-		if nums[mx] < nums[i] {
-			mx = i
-		}
-	}
-	return &TreeNode{
-		Val:   nums[mx],
-		Left:  construct(nums, l, mx-1),
-		Right: construct(nums, mx+1, r),
-	}
+    var dfs func(l, r int) *TreeNode
+    dfs = func(l, r int) *TreeNode {
+        if l > r {
+            return nil
+        }
+        i := l
+        for j := l; j <= r; j++ {
+            if nums[i] < nums[j] {
+                i = j
+            }
+        }
+        root := &TreeNode{Val: nums[i]}
+        root.Left = dfs(l, i - 1)
+        root.Right = dfs(i + 1, r)
+        return root
+    }
+    return dfs(0, len(nums)-1)
 }
 ```