Merge branch 'master' into master

Author: Cwlrin

problems/0027.移除元素.md

@@ -28,6 +28,8 @@
 
 ## 思路
 
+[本题B站视频讲解](https://www.bilibili.com/video/BV12A4y1Z7LP)
+
 有的同学可能说了，多余的元素，删掉不就得了。
 
 **要知道数组的元素在内存地址中是连续的，不能单独删除数组中的某个元素，只能覆盖。**
@@ -75,10 +77,20 @@ public:
 
 双指针法（快慢指针法）： **通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。**
 
+定义快慢指针 
+
+* 快指针：寻找新数组的元素 ，新数组就是不含有目标元素的数组
+* 慢指针：指向更新 新数组下标的位置
+
+很多同学这道题目做的很懵，就是不理解 快慢指针究竟都是什么含义，所以一定要明确含义，后面的思路就更容易理解了。
+
 删除过程如下：
 
 ![27.移除元素-双指针法](https://tva1.sinaimg.cn/large/008eGmZEly1gntrds6r59g30du09mnpd.gif)
 
+很多同学不了解
+
+
 **双指针法（快慢指针法）在数组和链表的操作中是非常常见的，很多考察数组、链表、字符串等操作的面试题，都使用双指针法。**
 
 后续都会一一介绍到，本题代码如下：
@@ -104,8 +116,6 @@ public:
 * 时间复杂度：O(n)
 * 空间复杂度：O(1)
 
-旧文链接：[数组：就移除个元素很难么？](https://programmercarl.com/0027.移除元素.html)
-
 ```CPP
 /**
 * 相向双指针方法，基于元素顺序可以改变的题目描述改变了元素相对位置，确保了移动最少元素
@@ -329,6 +339,17 @@ int removeElement(int* nums, int numsSize, int val){
 }
 ```
 
+Kotlin:
+```kotlin
+fun removeElement(nums: IntArray, `val`: Int): Int {
+        var slowIndex = 0 // 初始化慢指针
+        for (fastIndex in nums.indices) {
+            if (nums[fastIndex] != `val`) nums[slowIndex++] = nums[fastIndex] // 在慢指针所在位置存储未被删除的元素
+        }
+        return slowIndex
+    }
+```
+
 Scala:
 ```scala
 object Solution {
@@ -359,5 +380,6 @@ public class Solution {
     }
 }
 ```
+
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

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

@@ -73,8 +73,8 @@ public:
 };
 ```
 
-* 时间复杂度：$O(n)$
-* 空间复杂度：$O(1)$
+* 时间复杂度：O(n)
+* 空间复杂度：O(1)
 
 效率如下：
 
@@ -135,14 +135,14 @@ public:
         // 目标值在数组所有元素之前  [0, -1]
         // 目标值等于数组中某一个元素  return middle;
         // 目标值插入数组中的位置 [left, right]，return  right + 1
-        // 目标值在数组所有元素之后的情况 [left, right]， return right + 1
+        // 目标值在数组所有元素之后的情况 [left, right]， 因为是右闭区间，所以 return right + 1
         return right + 1;
     }
 };
 ```
 
-* 时间复杂度：$O(\log n)$
-* 时间复杂度：$O(1)$
+* 时间复杂度：O(log n)
+* 时间复杂度：O(1) 
 
 效率如下：
 ![35_搜索插入位置2](https://img-blog.csdnimg.cn/2020121623272877.png)
@@ -178,7 +178,7 @@ public:
         // 目标值在数组所有元素之前 [0,0)
         // 目标值等于数组中某一个元素 return middle
         // 目标值插入数组中的位置 [left, right) ，return right 即可
-        // 目标值在数组所有元素之后的情况 [left, right)，return right 即可
+        // 目标值在数组所有元素之后的情况 [left, right)，因为是右开区间，所以 return right
         return right;
     }
 };

problems/0042.接雨水.md

@@ -744,6 +744,91 @@ var trap = function(height) {
 };
 ```
 
+### TypeScript
+
+双指针法：
+
+```typescript
+function trap(height: number[]): number {
+    const length: number = height.length;
+    let resVal: number = 0;
+    for (let i = 0; i < length; i++) {
+        let leftMaxHeight: number = height[i],
+            rightMaxHeight: number = height[i];
+        let leftIndex: number = i - 1,
+            rightIndex: number = i + 1;
+        while (leftIndex >= 0) {
+            if (height[leftIndex] > leftMaxHeight)
+                leftMaxHeight = height[leftIndex];
+            leftIndex--;
+        }
+        while (rightIndex < length) {
+            if (height[rightIndex] > rightMaxHeight)
+                rightMaxHeight = height[rightIndex];
+            rightIndex++;
+        }
+        resVal += Math.min(leftMaxHeight, rightMaxHeight) - height[i];
+    }
+    return resVal;
+};
+```
+
+动态规划：
+
+```typescript
+function trap(height: number[]): number {
+    const length: number = height.length;
+    const leftMaxHeightDp: number[] = [],
+        rightMaxHeightDp: number[] = [];
+    leftMaxHeightDp[0] = height[0];
+    rightMaxHeightDp[length - 1] = height[length - 1];
+    for (let i = 1; i < length; i++) {
+        leftMaxHeightDp[i] = Math.max(height[i], leftMaxHeightDp[i - 1]);
+    }
+    for (let i = length - 2; i >= 0; i--) {
+        rightMaxHeightDp[i] = Math.max(height[i], rightMaxHeightDp[i + 1]);
+    }
+    let resVal: number = 0;
+    for (let i = 0; i < length; i++) {
+        resVal += Math.min(leftMaxHeightDp[i], rightMaxHeightDp[i]) - height[i];
+    }
+    return resVal;
+};
+```
+
+单调栈：
+
+```typescript
+function trap(height: number[]): number {
+    const length: number = height.length;
+    const stack: number[] = [];
+    stack.push(0);
+    let resVal: number = 0;
+    for (let i = 1; i < length; i++) {
+        let top = stack[stack.length - 1];
+        if (height[top] > height[i]) {
+            stack.push(i);
+        } else if (height[top] === height[i]) {
+            stack.pop();
+            stack.push(i);
+        } else {
+            while (stack.length > 0 && height[top] < height[i]) {
+                let mid = stack.pop();
+                if (stack.length > 0) {
+                    let left = stack[stack.length - 1];
+                    let h = Math.min(height[left], height[i]) - height[mid];
+                    let w = i - left - 1;
+                    resVal += h * w;
+                    top = stack[stack.length - 1];
+                }
+            }
+            stack.push(i);
+        }
+    }
+    return resVal;
+};
+```
+
 ### C:
 
 一种更简便的双指针方法：

problems/0046.全排列.md

@@ -341,7 +341,7 @@ function permute(nums: number[]): number[][] {
     return resArr;
     function backTracking(nums: number[], route: number[]): void {
         if (route.length === nums.length) {
-            resArr.push(route.slice());
+            resArr.push([...route]);
             return;
         }
         let tempVal: number;

problems/0047.全排列II.md

@@ -268,7 +268,7 @@ var permuteUnique = function (nums) {
 
     function backtracing( used) {
         if (path.length === nums.length) {
-            result.push(path.slice())
+            result.push([...path])
             return
         }
         for (let i = 0; i < nums.length; i++) {
@@ -303,7 +303,7 @@ function permuteUnique(nums: number[]): number[][] {
     return resArr;
     function backTracking(nums: number[], route: number[]): void {
         if (route.length === nums.length) {
-            resArr.push(route.slice());
+            resArr.push([...route]);
             return;
         }
         for (let i = 0, length = nums.length; i < length; i++) {

problems/0052.N皇后II.md

@@ -44,7 +44,7 @@ n 皇后问题研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并
 # 思路
 
 
-想看：[51.N皇后](https://mp.weixin.qq.com/s/lU_QwCMj6g60nh8m98GAWg) ，基本没有区别
+详看：[51.N皇后](https://mp.weixin.qq.com/s/lU_QwCMj6g60nh8m98GAWg) ，基本没有区别
 
 # C++代码
 

problems/0053.最大子序和（动态规划）.md

@@ -186,6 +186,24 @@ const maxSubArray = nums => {
 };
 ```
 
+TypeScript：
+
+```typescript
+function maxSubArray(nums: number[]): number {
+    /**
+        dp[i]：以nums[i]结尾的最大和
+     */
+    const dp: number[] = []
+    dp[0] = nums[0];
+    let resMax: number = 0;
+    for (let i = 1; i < nums.length; i++) {
+        dp[i] = Math.max(dp[i - 1] + nums[i], nums[i]);
+        resMax = Math.max(resMax, dp[i]);
+    }
+    return resMax;
+};
+```
+
 
 
 -----------------------

problems/0063.不同路径II.md

@@ -66,7 +66,7 @@ dp[i][j] ：表示从（0 ，0）出发，到(i, j) 有dp[i][j]条不同的路
 
 所以代码为：
 
-```
+```cpp
 if (obstacleGrid[i][j] == 0) { // 当(i, j)没有障碍的时候，再推导dp[i][j]
     dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
 }
@@ -76,7 +76,7 @@ if (obstacleGrid[i][j] == 0) { // 当(i, j)没有障碍的时候，再推导dp[i
 
 在[62.不同路径](https://programmercarl.com/0062.不同路径.html)不同路径中我们给出如下的初始化：
 
-```
+```cpp
 vector<vector<int>> dp(m, vector<int>(n, 0)); // 初始值为0
 for (int i = 0; i < m; i++) dp[i][0] = 1;
 for (int j = 0; j < n; j++) dp[0][j] = 1;
@@ -138,6 +138,8 @@ public:
     int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
         int m = obstacleGrid.size();
         int n = obstacleGrid[0].size();
+	if (obstacleGrid[m - 1][n - 1] == 1 || obstacleGrid[0][0] == 1) //如果在起点或终点出现了障碍，直接返回0
+            return 0;
         vector<vector<int>> dp(m, vector<int>(n, 0));
         for (int i = 0; i < m && obstacleGrid[i][0] == 0; i++) dp[i][0] = 1;
         for (int j = 0; j < n && obstacleGrid[0][j] == 0; j++) dp[0][j] = 1;

problems/0072.编辑距离.md

@@ -327,5 +327,42 @@ const minDistance = (word1, word2) => {
 };
 ```
 
+TypeScript：
+
+```typescript
+function minDistance(word1: string, word2: string): number {
+    /**
+        dp[i][j]: word1前i个字符，word2前j个字符，最少操作数
+        dp[0][0]=0：表示word1前0个字符为'', word2前0个字符为''
+     */
+    const length1: number = word1.length,
+        length2: number = word2.length;
+    const dp: number[][] = new Array(length1 + 1).fill(0)
+        .map(_ => new Array(length2 + 1).fill(0));
+    for (let i = 0; i <= length1; i++) {
+        dp[i][0] = i;
+    }
+    for (let i = 0; i <= length2; i++) {
+        dp[0][i] = i;
+    }
+    for (let i = 1; i <= length1; i++) {
+        for (let j = 1; j <= length2; j++) {
+            if (word1[i - 1] === word2[j - 1]) {
+                dp[i][j] = dp[i - 1][j - 1];
+            } else {
+                dp[i][j] = Math.min(
+                    dp[i - 1][j],
+                    dp[i][j - 1],
+                    dp[i - 1][j - 1]
+                ) + 1;
+            }
+        }
+    }
+    return dp[length1][length2];
+};
+```
+
+
+
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

problems/0078.子集.md

@@ -260,7 +260,7 @@ var subsets = function(nums) {
     let result = []
     let path = []
     function backtracking(startIndex) {
-        result.push(path.slice())
+        result.push([...path])
         for(let i = startIndex; i < nums.length; i++) {
             path.push(nums[i])
             backtracking(i + 1)
@@ -280,7 +280,7 @@ function subsets(nums: number[]): number[][] {
     backTracking(nums, 0, []);
     return resArr;
     function backTracking(nums: number[], startIndex: number, route: number[]): void {
-        resArr.push(route.slice());
+        resArr.push([...route]);
         let length = nums.length;
         if (startIndex === length) return;
         for (let i = startIndex; i < length; i++) {