Merge branch 'youngyangyang04:master' into master

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/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

problems/0300.最长上升子序列.md

@@ -168,6 +168,39 @@ func lengthOfLIS(nums []int ) int {
 }
 ```
 
+```go
+// 动态规划求解
+func lengthOfLIS(nums []int) int {
+    // dp数组的定义 dp[i]表示取第i个元素的时候，表示子序列的长度，其中包括 nums[i] 这个元素
+    dp := make([]int, len(nums))
+
+    // 初始化，所有的元素都应该初始化为1
+    for i := range dp {
+        dp[i] = 1
+    }
+
+    ans := dp[0]
+    for i := 1; i < len(nums); i++ {
+        for j := 0; j < i; j++ {
+            if nums[i] > nums[j] {
+                dp[i] = max(dp[i], dp[j] + 1)
+            }
+        }
+        if dp[i] > ans {
+            ans = dp[i]
+        }
+    }
+    return ans
+}
+
+func max(x, y int) int {
+    if x > y {
+        return x
+    }
+    return y
+}
+```
+
 Javascript
 ```javascript
 const lengthOfLIS = (nums) => {

problems/0383.赎金信.md

@@ -114,23 +114,25 @@ Java：
 ```Java
 class Solution {
     public boolean canConstruct(String ransomNote, String magazine) {
-        //记录杂志字符串出现的次数
-        int[] arr = new int[26];
-        int temp;
-        for (int i = 0; i < magazine.length(); i++) {
-            temp = magazine.charAt(i) - 'a';
-            arr[temp]++;
+        // 定义一个哈希映射数组
+        int[] record = new int[26];
+
+        // 遍历
+        for(char c : magazine.toCharArray()){
+            record[c - 'a'] += 1;
         }
-        for (int i = 0; i < ransomNote.length(); i++) {
-            temp = ransomNote.charAt(i) - 'a';
-            //对于金信中的每一个字符都在数组中查找
-            //找到相应位减一，否则找不到返回false
-            if (arr[temp] > 0) {
-                arr[temp]--;
-            } else {
+
+        for(char c : ransomNote.toCharArray()){
+            record[c - 'a'] -= 1;
+        }
+        
+        // 如果数组中存在负数，说明ransomNote字符串总存在magazine中没有的字符
+        for(int i : record){
+            if(i < 0){
                 return false;
             }
         }
+
         return true;
     }
 }

problems/0496.下一个更大元素I.md

@@ -244,6 +244,39 @@ class Solution:
 ```
 
 Go：
+
+> 未精简版本
+```go
+func nextGreaterElement(nums1 []int, nums2 []int) []int {
+    res := make([]int, len(nums1))
+    for i := range res { res[i] = -1 }
+    m := make(map[int]int, len(nums1))
+    for k, v := range nums1 { m[v] = k }
+
+    stack := []int{0}
+    for i := 1; i < len(nums2); i++ {
+        top := stack[len(stack)-1]
+        if nums2[i] < nums2[top] {
+            stack = append(stack, i)
+        } else if nums2[i] == nums2[top] {
+            stack = append(stack, i)
+        } else {
+            for len(stack) != 0 && nums2[i] > nums2[top] {
+                if v, ok := m[nums2[top]]; ok {
+                    res[v] = nums2[i]
+                }
+                stack = stack[:len(stack)-1]
+                if len(stack) != 0 {
+                    top = stack[len(stack)-1]
+                }
+            }
+            stack = append(stack, i)
+        }
+    }
+    return res
+}
+```
+> 精简版本
 ```go
 func nextGreaterElement(nums1 []int, nums2 []int) []int {
     res := make([]int, len(nums1))

problems/0509.斐波那契数.md

@@ -245,7 +245,29 @@ var fib = function(n) {
 };
 ```
 
+TypeScript
+
+```typescript
+function fib(n: number): number {
+    /**
+        dp[i]: 第i个斐波那契数
+        dp[0]: 0;
+        dp[1]：1；
+        ...
+        dp[i] = dp[i - 1] + dp[i - 2];
+     */
+    const dp: number[] = [];
+    dp[0] = 0;
+    dp[1] = 1;
+    for (let i = 2; i <= n; i++) {
+        dp[i] = dp[i - 1] + dp[i - 2];
+    }
+    return dp[n];
+};
+```
+
 ### C
+
 动态规划:
 ```c
 int fib(int n){

problems/0674.最长连续递增序列.md

@@ -236,6 +236,45 @@ class Solution:
 ```
 
 Go：
+> 动态规划：
+```go
+func findLengthOfLCIS(nums []int) int {
+	if len(nums) == 0 {return 0}
+	res, count := 1, 1
+	for i := 0; i < len(nums)-1; i++ {
+		if nums[i+1] > nums[i] {
+			count++
+		}else {
+			count = 1
+		}
+		if count > res {
+			res = count
+		}
+	}
+	return res
+}
+```
+
+> 贪心算法：
+```go
+func findLengthOfLCIS(nums []int) int {
+	if len(nums) == 0 {return 0}
+	dp := make([]int, len(nums))
+	for i := 0; i < len(dp); i++ {
+		dp[i] = 1
+	}
+	res := 1
+	for i := 0; i < len(nums)-1; i++ {
+		if nums[i+1] > nums[i] {
+			dp[i+1] = dp[i] + 1
+		}
+		if dp[i+1] > res {
+			res = dp[i+1]
+		}
+	}
+	return res
+}
+```
 
 Javascript：
 

problems/0739.每日温度.md

@@ -34,7 +34,7 @@
 
 那么单调栈的原理是什么呢？为什么时间复杂度是O(n)就可以找到每一个元素的右边第一个比它大的元素位置呢？
 
-单调栈的本质是空间换时间，因为在遍历的过程中需要用一个栈来记录右边第一个比当前元素的元素，优点是只需要遍历一次。
+单调栈的本质是空间换时间，因为在遍历的过程中需要用一个栈来记录右边第一个比当前元素大的元素，优点是只需要遍历一次。
 
 
 在使用单调栈的时候首先要明确如下几点：
@@ -233,7 +233,7 @@ class Solution {
 }
 ```
 Python：
-``` Python3
+```python
 class Solution:
     def dailyTemperatures(self, temperatures: List[int]) -> List[int]:
         answer = [0]*len(temperatures)
@@ -277,8 +277,36 @@ func dailyTemperatures(t []int) []int {
 }
 ```
 
-> 单调栈法
+> 单调栈法(未精简版本)
 
+```go
+func dailyTemperatures(temperatures []int) []int {
+    res := make([]int, len(temperatures))
+    // 初始化栈顶元素为第一个下标索引0
+    stack := []int{0}
+
+    for i := 1; i < len(temperatures); i++ {
+        top := stack[len(stack)-1]
+        if temperatures[i] < temperatures[top] {
+            stack = append(stack, i)
+        } else if temperatures[i] ==  temperatures[top] {
+            stack = append(stack, i)
+        } else {
+            for len(stack) != 0 && temperatures[i] > temperatures[top] {
+                res[top] = i - top
+                stack = stack[:len(stack)-1]
+                if len(stack) != 0 {
+                    top = stack[len(stack)-1]
+                }
+            }
+            stack = append(stack, i)
+        }
+    }
+    return res
+}
+```
+
+> 单调栈法(精简版本)
 ```go
 // 单调递减栈
 func dailyTemperatures(num []int) []int {

problems/0746.使用最小花费爬楼梯.md

@@ -266,7 +266,30 @@ var minCostClimbingStairs = function(cost) {
 };
 ```
 
+### TypeScript
+
+```typescript
+function minCostClimbingStairs(cost: number[]): number {
+    /**
+        dp[i]: 走到第i阶需要花费的最少金钱
+        dp[0]: cost[0];
+        dp[1]: cost[1];
+        ...
+        dp[i]: min(dp[i - 1], dp[i - 2]) + cost[i];
+     */
+    const dp: number[] = [];
+    const length: number = cost.length;
+    dp[0] = cost[0];
+    dp[1] = cost[1];
+    for (let i = 2; i <= length; i++) {
+        dp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i];
+    }
+    return Math.min(dp[length - 1], dp[length - 2]);
+};
+```
+
 ### C
+
 ```c
 int minCostClimbingStairs(int* cost, int costSize){
     //开辟dp数组，大小为costSize

problems/0968.监控二叉树.md

@@ -476,7 +476,35 @@ var minCameraCover = function(root) {
 };
 ```
 
+### TypeScript
+
+```typescript
+function minCameraCover(root: TreeNode | null): number {
+    /** 0-无覆盖， 1-有摄像头， 2-有覆盖 */
+    type statusCode = 0 | 1 | 2;
+    let resCount: number = 0;
+    if (recur(root) === 0) resCount++;
+    return resCount;
+    function recur(node: TreeNode | null): statusCode {
+        if (node === null) return 2;
+        const left: statusCode = recur(node.left),
+            right: statusCode = recur(node.right);
+        let resStatus: statusCode = 0;
+        if (left === 0 || right === 0) {
+            resStatus = 1;
+            resCount++;
+        } else if (left === 1 || right === 1) {
+            resStatus = 2;
+        } else {
+            resStatus = 0;
+        }
+        return resStatus;
+    }
+};
+```
+
 ### C 
+
 ```c
 /*
 **函数后序遍历二叉树。判断一个结点状态时，根据其左右孩子结点的状态进行判断

problems/二叉树的迭代遍历.md

@@ -11,9 +11,9 @@
 
 看完本篇大家可以使用迭代法，再重新解决如下三道leetcode上的题目：
 
-* 144.二叉树的前序遍历
-* 94.二叉树的中序遍历
-* 145.二叉树的后序遍历
+* [144.二叉树的前序遍历](https://leetcode-cn.com/problems/binary-tree-preorder-traversal/)
+* [94.二叉树的中序遍历](https://leetcode-cn.com/problems/binary-tree-inorder-traversal/)
+* [145.二叉树的后序遍历](https://leetcode-cn.com/problems/binary-tree-postorder-traversal/)
 
 为什么可以用迭代法（非递归的方式）来实现二叉树的前后中序遍历呢？
 

problems/二叉树的递归遍历.md

@@ -99,9 +99,9 @@ void traversal(TreeNode* cur, vector<int>& vec) {
 
 此时大家可以做一做leetcode上三道题目，分别是：
 
-* 144.二叉树的前序遍历
-* 145.二叉树的后序遍历
-* 94.二叉树的中序遍历
+* [144.二叉树的前序遍历](https://leetcode-cn.com/problems/binary-tree-preorder-traversal/)
+* [145.二叉树的后序遍历](https://leetcode-cn.com/problems/binary-tree-postorder-traversal/)
+* [94.二叉树的中序遍历](https://leetcode-cn.com/problems/binary-tree-inorder-traversal/)
 
 可能有同学感觉前后中序遍历的递归太简单了，要打迭代法（非递归），别急，我们明天打迭代法，打个通透！
 

problems/背包理论基础01背包-1.md

@@ -380,28 +380,37 @@ func main() {
 ### javascript 
 
 ```js
-function testweightbagproblem (wight, value, size) {
-  const len = wight.length, 
-    dp = array.from({length: len + 1}).map(
-      () => array(size + 1).fill(0)
-    );
+/**
+ * 
+ * @param {Number []} weight 
+ * @param {Number []} value 
+ * @param {Number} size 
+ * @returns 
+ */
 
-  for(let i = 1; i <= len; i++) {
-    for(let j = 0; j <= size; j++) {
-      if(wight[i - 1] <= j) {
-        dp[i][j] = math.max(
-          dp[i - 1][j], 
-          value[i - 1] + dp[i - 1][j - wight[i - 1]]
-        )
-      } else {
-        dp[i][j] = dp[i - 1][j];
-      }
-    }
-  }
+function testWeightBagProblem(weight, value, size) {
+const len = weight.length,
+dp = Array.from({length: len}).map(
+() => Array(size + 1))  //JavaScript 数组是引用类型	
+for(let i = 0; i < len; i++) {  //初始化最左一列，即背包容量为0时的情况
+dp[i][0] = 0;
+}
+for(let j = 1; j < size+1; j++) { //初始化第0行, 只有一件物品的情况
+if(weight[0] <= j) {
+dp[0][j] = value[0];
+} else {
+dp[0][j] = 0;
+}
+}
 	
-//   console.table(dp);
+for(let i = 1; i < len; i++) {  //dp[i][j]由其左上方元素推导得出
+for(let j = 1; j < size+1; j++) {
+if(j < weight[i]) dp[i][j] = dp[i - 1][j];
+else dp[i][j] = Math.max(dp[i-1][j], dp[i-1][j - weight[i]] + value[i]);
+}
+}
 
-  return dp[len][size];
+return dp[len-1][size] //满足条件的最大值
 }
 
 function testWeightBagProblem2 (wight, value, size) {