Merge branch 'youngyangyang04:master' into master

Author: lizhendong128

README.md

@@ -254,7 +254,7 @@
 33. [二叉树：构造一棵搜索树](./problems/0108.将有序数组转换为二叉搜索树.md)
 34. [二叉树：搜索树转成累加树](./problems/0538.把二叉搜索树转换为累加树.md)
 35. [二叉树：总结篇！（需要掌握的二叉树技能都在这里了）](./problems/二叉树总结篇.md)
- 
+
 ## 回溯算法 
 
 题目分类大纲如下：             

problems/0015.三数之和.md

@@ -313,54 +313,36 @@ func threeSum(nums []int)[][]int{
 javaScript: 
 
 ```js
-/**
- * @param {number[]} nums
- * @return {number[][]}
- */
-
-// 循环内不考虑去重 
-var threeSum = function(nums) {
-    const len = nums.length;
-    if(len < 3) return [];
-    nums.sort((a, b) => a - b);
-    const resSet = new Set();
-    for(let i = 0; i < len - 2; i++) {
-        if(nums[i] > 0) break;
-        let l = i + 1, r = len - 1;
-        while(l < r) {
-            const sum = nums[i] + nums[l] + nums[r];
-            if(sum < 0) { l++; continue };
-            if(sum > 0) { r--; continue };
-            resSet.add(`${nums[i]},${nums[l]},${nums[r]}`);
-            l++;
-            r--;
-        }
-    }
-    return Array.from(resSet).map(i => i.split(","));
-};
-
-// 去重优化
 var threeSum = function(nums) {
-    const len = nums.length;
-    if(len < 3) return [];
-    nums.sort((a, b) => a - b);
-    const res = [];
-    for(let i = 0; i < len - 2; i++) {
-        if(nums[i] > 0) break;
-        // a去重
-        if(i > 0 && nums[i] === nums[i - 1]) continue;
-        let l = i + 1, r = len - 1;
+    const res = [], len = nums.length
+    // 将数组排序
+    nums.sort((a, b) => a - b)
+    for (let i = 0; i < len; i++) {
+        let l = i + 1, r = len - 1, iNum = nums[i]
+        // 数组排过序，如果第一个数大于0直接返回res
+        if (iNum > 0) return res
+        // 去重
+        if (iNum == nums[i - 1]) continue
         while(l < r) {
-            const sum = nums[i] + nums[l] + nums[r];
-            if(sum < 0) { l++; continue };
-            if(sum > 0) { r--; continue };
-            res.push([nums[i], nums[l], nums[r]])
-            // b c 去重 
-            while(l < r && nums[l] === nums[++l]);
-            while(l < r && nums[r] === nums[--r]);
+            let lNum = nums[l], rNum = nums[r], threeSum = iNum + lNum + rNum
+            // 三数之和小于0，则左指针向右移动
+            if (threeSum < 0) l++ 
+            else if (threeSum > 0) r--
+            else {
+                res.push([iNum, lNum, rNum])
+                // 去重
+                while(l < r && nums[l] == nums[l + 1]){
+                    l++
+                }
+                while(l < r && nums[r] == nums[r - 1]) {
+                    r--
+                }
+                l++
+                r--
+            }
         }
     }
-    return res;
+    return res
 };
 ```
 TypeScript:

problems/0035.搜索插入位置.md

@@ -318,6 +318,31 @@ func searchInsert(_ nums: [Int], _ target: Int) -> Int {
 ```
 
 
+### PHP 
+
+```php
+// 二分法(1)：[左闭右闭]
+function searchInsert($nums, $target)
+{
+    $n = count($nums);
+    $l = 0;
+    $r = $n - 1;
+    while ($l <= $r) {
+        $mid = floor(($l + $r) / 2);
+        if ($nums[$mid] > $target) {
+            // 下次搜索在左区间：[$l,$mid-1]
+            $r = $mid - 1;
+        } else if ($nums[$mid] < $target) {
+			// 下次搜索在右区间：[$mid+1,$r]
+			$l = $mid + 1;
+		} else {
+			// 命中返回
+			return $mid;
+		}
+    }
+    return $r + 1;
+}
+```
 
 
 -----------------------

problems/0039.组合总和.md

@@ -370,18 +370,17 @@ func backtracking(startIndex,sum,target int,candidates,trcak []int,res *[][]int)
 ```js
 var combinationSum = function(candidates, target) {
     const res = [], path = [];
-    candidates.sort(); // 排序
+    candidates.sort((a,b)=>a-b); // 排序
     backtracking(0, 0);
     return res;
     function backtracking(j, sum) {
-        if (sum > target) return;
         if (sum === target) {
             res.push(Array.from(path));
             return;
         }
         for(let i = j; i < candidates.length; i++ ) {
             const n = candidates[i];
-            if(n > target - sum) continue;
+            if(n > target - sum) break;
             path.push(n);
             sum += n;
             backtracking(i, sum);

problems/0040.组合总和II.md

@@ -508,22 +508,27 @@ func backtracking(startIndex,sum,target int,candidates,trcak []int,res *[][]int)
  */
 var combinationSum2 = function(candidates, target) {
     const res = []; path = [], len = candidates.length;
-    candidates.sort();
+    candidates.sort((a,b)=>a-b);
     backtracking(0, 0);
     return res;
     function backtracking(sum, i) {
-        if (sum > target) return;
         if (sum === target) {
             res.push(Array.from(path));
             return;
         }
-        let f = -1;
         for(let j = i; j < len; j++) {
             const n = candidates[j];
-            if(n > target - sum || n === f) continue;
+            if(j > i && candidates[j] === candidates[j-1]){
+              //若当前元素和前一个元素相等
+              //则本次循环结束，防止出现重复组合
+              continue;
+            }
+            //如果当前元素值大于目标值-总和的值
+            //由于数组已排序，那么该元素之后的元素必定不满足条件
+            //直接终止当前层的递归
+            if(n > target - sum) break;
             path.push(n);
             sum += n;
-            f = n;
             backtracking(sum, j + 1);
             path.pop();
             sum -= n;

problems/0053.最大子序和.md

@@ -140,7 +140,7 @@ public:
 ## 其他语言版本
 
 
-### Java 
+### Java
 ```java
 class Solution {
     public int maxSubArray(int[] nums) {
@@ -180,7 +180,7 @@ class Solution {
 }
 ```
 
-### Python 
+### Python
 ```python
 class Solution:
     def maxSubArray(self, nums: List[int]) -> int:
@@ -195,7 +195,7 @@ class Solution:
         return result
 ```
 
-### Go 
+### Go
 
 ```go
 func maxSubArray(nums []int) int {
@@ -212,6 +212,20 @@ func maxSubArray(nums []int) int {
 }
 ```
 
+### Rust
+```rust
+pub fn max_sub_array(nums: Vec<i32>) -> i32 {
+    let mut max_sum = i32::MIN;
+    let mut curr = 0;
+    for n in nums.iter() {
+        curr += n;
+        max_sum = max_sum.max(curr);
+        curr = curr.max(0);
+    }
+    max_sum
+}
+```
+
 ### Javascript:
 ```Javascript
 var maxSubArray = function(nums) {

problems/0062.不同路径.md

@@ -273,7 +273,7 @@ public:
         return dp[m-1][n-1];
     }
 
-``` 
+```
 
 ### Python 
 ```python
@@ -347,7 +347,35 @@ var uniquePaths = function(m, n) {
 };
 ```
 
+### TypeScript
+
+```typescript
+function uniquePaths(m: number, n: number): number {
+    /**
+        dp[i][j]: 到达(i, j)的路径数
+        dp[0][*]: 1;
+        dp[*][0]: 1;
+        ...
+        dp[i][j]: dp[i - 1][j] + dp[i][j - 1];
+     */
+    const dp: number[][] = new Array(m).fill(0).map(_ => []);
+    for (let i = 0; i < m; i++) {
+        dp[i][0] = 1;
+    }
+    for (let i = 0; i < n; i++) {
+        dp[0][i] = 1;
+    }
+    for (let i = 1; i < m; i++) {
+        for (let j = 1; j < n; j++) {
+            dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
+        }
+    }
+    return dp[m - 1][n - 1];
+};
+```
+
 ### C
+
 ```c
 //初始化dp数组
 int **initDP(int m, int n) {

problems/0063.不同路径II.md

@@ -352,7 +352,38 @@ var uniquePathsWithObstacles = function(obstacleGrid) {
 };
 ```
 
-C
+### TypeScript
+
+```typescript
+function uniquePathsWithObstacles(obstacleGrid: number[][]): number {
+    /**
+        dp[i][j]: 到达(i, j)的路径数
+        dp[0][*]: 用u表示第一个障碍物下标，则u之前为1，u之后（含u）为0
+        dp[*][0]: 同上
+        ...
+        dp[i][j]: obstacleGrid[i][j] === 1 ? 0 : dp[i-1][j] + dp[i][j-1];
+     */
+    const m: number = obstacleGrid.length;
+    const n: number = obstacleGrid[0].length;
+    const dp: number[][] = new Array(m).fill(0).map(_ => new Array(n).fill(0));
+    for (let i = 0; i < m && obstacleGrid[i][0] === 0; i++) {
+        dp[i][0] = 1;
+    }
+    for (let i = 0; i < n && obstacleGrid[0][i] === 0; i++) {
+        dp[0][i] = 1;
+    }
+    for (let i = 1; i < m; i++) {
+        for (let j = 1; j < n; j++) {
+            if (obstacleGrid[i][j] === 1) continue;
+            dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
+        }
+    }
+    return dp[m - 1][n - 1];
+};
+```
+
+### C
+
 ```c
 //初始化dp数组
 int **initDP(int m, int n, int** obstacleGrid) {

problems/0070.爬楼梯.md

@@ -308,7 +308,58 @@ var climbStairs = function(n) {
 };
 ```
 
+TypeScript
+
+> 爬2阶
+
+```typescript
+function climbStairs(n: number): number {
+    /**
+        dp[i]: i阶楼梯的方法种数
+        dp[1]: 1;
+        dp[2]: 2;
+        ...
+        dp[i]: dp[i - 1] + dp[i - 2];
+     */
+    const dp: number[] = [];
+    dp[1] = 1;
+    dp[2] = 2;
+    for (let i = 3; i <= n; i++) {
+        dp[i] = dp[i - 1] + dp[i - 2];
+    }
+    return dp[n];
+};
+```
+
+> 爬m阶
+
+```typescript
+function climbStairs(n: number): number {
+    /**
+        一次可以爬m阶
+        dp[i]: i阶楼梯的方法种数
+        dp[1]: 1;
+        dp[2]: 2;
+        dp[3]: dp[2] + dp[1];
+        ...
+        dp[i]: dp[i - 1] + dp[i - 2] + ... + dp[max(i - m, 1)]; 从i-1加到max(i-m, 1)
+     */
+    const m: number = 2;    // 本题m为2
+    const dp: number[] = new Array(n + 1).fill(0);
+    dp[1] = 1;
+    dp[2] = 2;
+    for (let i = 3; i <= n; i++) {
+        const end: number = Math.max(i - m, 1);
+        for (let j = i - 1; j >= end; j--) {
+            dp[i] += dp[j];
+        }
+    }
+    return dp[n];
+};
+```
+
 ### C
+
 ```c
 int climbStairs(int n){
     //若n<=2，返回n