Merge branch 'master' into master

Author: youngyangyang04

README.md

@@ -105,8 +105,11 @@
 3. [数组：27.移除元素](./problems/0027.移除元素.md)
 4. [数组：977.有序数组的平方](./problems/0977.有序数组的平方.md)    
 5. [数组：209.长度最小的子数组](./problems/0209.长度最小的子数组.md)
+6. [数组：区间和](./problems/kamacoder/0058.区间和.md)
 6. [数组：59.螺旋矩阵II](./problems/0059.螺旋矩阵II.md)
-7. [数组：总结篇](./problems/数组总结篇.md)
+7. [数组：区间和](./problems/kamacoder/0058.区间和.md)
+8. [数组：开发商购买土地](./problems/kamacoder/0044.开发商购买土地.md)
+9. [数组：总结篇](./problems/数组总结篇.md)
 
 ## 链表
 

problems/0018.四数之和.md

@@ -262,6 +262,11 @@ class Solution {
             
             for (int j = i + 1; j < nums.length; j++) {
 
+		// nums[i]+nums[j] > target 直接返回, 剪枝操作
+		            if (nums[i]+nums[j] > 0 && nums[i]+nums[j] > target) {
+		                return result;
+		            }
+
                 if (j > i + 1 && nums[j - 1] == nums[j]) {  // 对nums[j]去重
                     continue;
                 }

problems/0046.全排列.md

@@ -42,7 +42,8 @@
 
 我以[1,2,3]为例，抽象成树形结构如下：
 
-![46.全排列](https://code-thinking-1253855093.file.myqcloud.com/pics/20211027181706.png)
+
+![全排列](https://code-thinking-1253855093.file.myqcloud.com/pics/20240803180318.png)
 
 ### 回溯三部曲
 
@@ -54,7 +55,7 @@
 
 但排列问题需要一个used数组，标记已经选择的元素，如图橘黄色部分所示:
 
-![46.全排列](https://code-thinking-1253855093.file.myqcloud.com/pics/20211027181706.png)
+![全排列](https://code-thinking-1253855093.file.myqcloud.com/pics/20240803180318.png)
 
 代码如下：
 
@@ -66,7 +67,7 @@ void backtracking (vector<int>& nums, vector<bool>& used)
 
 * 递归终止条件
 
-![46.全排列](https://code-thinking-1253855093.file.myqcloud.com/pics/20201209174225145.png)
+![全排列](https://code-thinking-1253855093.file.myqcloud.com/pics/20240803180318.png)
 
 可以看出叶子节点，就是收割结果的地方。
 

problems/0062.不同路径.md

@@ -371,6 +371,7 @@ class Solution:
 ```
 ### Go
 
+动态规划
 ```Go
 func uniquePaths(m int, n int) int {
 	dp := make([][]int, m)
@@ -390,6 +391,26 @@ func uniquePaths(m int, n int) int {
 }
 ```
 
+数论方法
+```Go
+func uniquePaths(m int, n int) int {
+    numerator := 1
+    denominator := m - 1
+    count := m - 1
+    t := m + n - 2
+    for count > 0 {
+        numerator *= t
+        t--
+        for denominator != 0 && numerator % denominator == 0 {
+            numerator /= denominator
+            denominator--
+        }
+        count--
+    }
+    return numerator
+}
+```
+
 ### Javascript
 
 ```Javascript

problems/0078.子集.md

@@ -287,6 +287,7 @@ function subsets(nums: number[]): number[][] {
 
 ### Rust
 
+思路一：使用本题的标准解法，递归回溯。
 ```Rust
 impl Solution {
     fn backtracking(result: &mut Vec<Vec<i32>>, path: &mut Vec<i32>, nums: &Vec<i32>, start_index: usize) {
@@ -308,6 +309,30 @@ impl Solution {
     }
 }
 ```
+思路二：使用二进制枚举，n个元素的子集问题一共是$2^n$种情况。如果我们使用一个二进制数字，每一位根据0和1来决定是选取该元素与否，那么一共也是$2^n$的情况，正好可以一一对应，所以我们可以不使用递归，直接利用循环枚举完成子集问题。
+这种方法的优点在于效率高，不需要递归调用，并且代码容易编写。缺点则是过滤某些非法情况时会比递归方法难写一点，不过在子集问题中不存在这个问题。
+```Rust
+impl Solution {
+    pub fn subsets(nums: Vec<i32>) -> Vec<Vec<i32>> {
+        let n = nums.len();
+        // 预分配2^n空间
+        let mut result = Vec::with_capacity(1 << n);
+        // 二进制枚举，2^n种情况
+        for i in 0..(1 << n) {
+            let mut subset = Vec::new();
+            for j in 0..n {
+                // 枚举该二进制数字的每一位
+                // 如果该位是1，对应位置上的元素加入子集，否则跳过
+                if i & (1 << j) != 0 {
+                    subset.push(nums[j]);
+                }
+            }
+            result.push(subset);
+        }
+        result
+    }
+}
+```
 
 ### C
 

problems/0106.从中序与后序遍历序列构造二叉树.md

@@ -794,6 +794,60 @@ func rebuild(inorder []int, postorder []int, rootIdx int, l, r int) *TreeNode {
 }
 ```
 
+```go
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func buildTree(inorder []int, postorder []int) *TreeNode {
+    if len(postorder) == 0 {
+        return nil
+    }
+    
+    // 后序遍历数组最后一个元素，就是当前的中间节点
+    rootValue := postorder[len(postorder)-1]
+    root := &TreeNode{Val:rootValue}
+    
+    // 叶子结点
+    if len(postorder) == 1 {
+        return root
+    }
+    
+    // 找到中序遍历的切割点
+    var delimiterIndex int
+    for delimiterIndex = 0; delimiterIndex < len(inorder); delimiterIndex++ {
+        if inorder[delimiterIndex] == rootValue {
+            break;
+        }
+    }
+    
+    // 切割中序数组
+    // 左闭右开区间：[0, delimiterIndex)
+    leftInorder := inorder[:delimiterIndex]
+    // [delimiterIndex + 1, end)
+    rightInorder := inorder[delimiterIndex+1:]
+    
+    // postorder 舍弃末尾元素
+    postorder = postorder[:len(postorder)-1]
+    
+    // 切割后序数组
+    // 依然左闭右开，注意这里使用了左中序数组大小作为切割点
+    // [0, len(leftInorder))
+    leftPostorder := postorder[:len(leftInorder)]
+    // [len(leftInorder), end)
+    rightPostorder := postorder[len(leftInorder):]
+    
+    root.Left = buildTree(leftInorder, leftPostorder)
+    root.Right = buildTree(rightInorder, rightPostorder)
+    
+    return root
+}
+```
+
 105 从前序与中序遍历序列构造二叉树
 
 ```go
@@ -829,6 +883,60 @@ func build(pre []int, in []int, root int, l, r int) *TreeNode {
 }
 ```
 
+```go
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func buildTree(preorder []int, inorder []int) *TreeNode {
+    if len(preorder) == 0 {
+        return nil
+    }
+    
+    // 前序遍历数组第一个元素，就是当前的中间节点
+    rootValue := preorder[0]
+    root := &TreeNode{Val:rootValue}
+    
+    // 叶子结点
+    if len(preorder) == 1 {
+        return root
+    }
+    
+    // 找到中序遍历的切割点
+    var delimiterIndex int
+    for delimiterIndex = 0; delimiterIndex < len(inorder); delimiterIndex++ {
+        if inorder[delimiterIndex] == rootValue {
+            break
+        }
+    }
+    
+    // 切割中序数组
+    // 左闭右开区间：[0, delimiterIndex)
+    leftInorder := inorder[:delimiterIndex]
+    // [delimiterIndex + 1, end)
+    rightInorder := inorder[delimiterIndex+1:]
+    
+    // preorder 舍弃首位元素
+    preorder = preorder[1:]
+    
+    // 切割前序数组
+    // 依然左闭右开，注意这里使用了左中序数组大小作为切割点
+    // [0, len(leftInorder))
+    leftPreorder := preorder[:len(leftInorder)]
+    // [len(leftInorder), end)
+    rightPreorder := preorder[len(leftInorder):]
+    
+    root.Left = buildTree(leftPreorder, leftInorder)
+    root.Right = buildTree(rightPreorder, rightInorder)
+    
+    return root
+}
+```
+
 
 ### JavaScript
 

problems/0110.平衡二叉树.md

@@ -623,6 +623,8 @@ class Solution:
 ```
 ### Go:
 
+递归法
+
 ```Go
 func isBalanced(root *TreeNode) bool {
     h := getHeight(root)
@@ -653,6 +655,64 @@ func max(a, b int) int {
 }
 ```
 
+迭代法
+
+```Go
+func isBalanced(root *TreeNode) bool {
+    st := make([]*TreeNode, 0)
+    if root == nil {
+        return true
+    }
+    st = append(st, root)
+    for len(st) > 0 {
+        node := st[len(st)-1]
+        st = st[:len(st)-1]
+        if math.Abs(float64(getDepth(node.Left)) - float64(getDepth(node.Right))) > 1 {
+            return false
+        }
+        if node.Right != nil {
+            st = append(st, node.Right)
+        }
+        if node.Left != nil {
+            st = append(st, node.Left)
+        }
+    }
+    return true
+}
+
+func getDepth(cur *TreeNode) int {
+    st := make([]*TreeNode, 0)
+    if cur != nil {
+        st = append(st, cur)
+    }
+    depth := 0
+    result := 0
+    for len(st) > 0 {
+        node := st[len(st)-1]
+        if node != nil {
+            st = st[:len(st)-1]
+            st = append(st, node, nil)
+            depth++
+            if node.Right != nil {
+                st = append(st, node.Right)
+            }
+            if node.Left != nil {
+                st = append(st, node.Left)
+            }
+        } else {
+            st = st[:len(st)-1]
+            node = st[len(st)-1]
+            st = st[:len(st)-1]
+            depth--
+        }
+        if result < depth {
+            result = depth
+        }
+    }
+    return result
+}
+```
+
 ### JavaScript:
 
 递归法：

problems/0121.买卖股票的最佳时机.md

@@ -308,7 +308,7 @@ class Solution:
 class Solution:
     def maxProfit(self, prices: List[int]) -> int:
         length = len(prices)
-        if len == 0:
+        if length == 0:
             return 0
         dp = [[0] * 2 for _ in range(length)]
         dp[0][0] = -prices[0]
@@ -466,7 +466,7 @@ function maxProfit(prices: number[]): number {
 };
 ```
 
-> 动态规划
+> 动态规划：版本一
 
 ```typescript
 function maxProfit(prices: number[]): number {
@@ -487,6 +487,26 @@ function maxProfit(prices: number[]): number {
 };
 ```
 
+> 动态规划：版本二
+
+```typescript
+// dp[i][0] 表示第i天持有股票所得最多现金
+// dp[i][1] 表示第i天不持有股票所得最多现金
+function maxProfit(prices: number[]): number {
+    const dp:number[][] = Array(2).fill(0).map(item => Array(2));
+    dp[0][0] = -prices[0];
+    dp[0][1] = 0;
+    
+    for (let i = 1; i < prices.length; i++) {
+        dp[i % 2][0] = Math.max(dp[(i - 1) % 2][0], -prices[i]);
+        dp[i % 2][1] = Math.max(dp[(i - 1) % 2][1], dp[(i - 1) % 2][0] + prices[i]);
+    }
+
+    // 返回不持有股票的最大现金
+    return dp[(prices.length-1) % 2][1];
+};
+```
+
 ### C#：
 
 > 贪心法