Merge branch 'master' of github.com:youngyangyang04/leetcode-master

Author: youngyangyang04

problems/0001.两数之和.md

@@ -349,6 +349,7 @@ function twoSum(nums: number[], target: number): number[] {
         index = helperMap.get(target - nums[i]);
         if (index !== undefined) {
             resArr = [i, index];
+            break;
         }
         helperMap.set(nums[i], i);
     }

problems/0017.电话号码的字母组合.md

@@ -260,7 +260,7 @@ class Solution {
 
     }
 
-    //每次迭代获取一个字符串，所以会设计大量的字符串拼接，所以这里选择更为高效的 StringBuilder
+    //每次迭代获取一个字符串，所以会涉及大量的字符串拼接，所以这里选择更为高效的 StringBuilder
     StringBuilder temp = new StringBuilder();
 
     //比如digits如果为"23",num 为0，则str表示2对应的 abc
@@ -274,7 +274,7 @@ class Solution {
         String str = numString[digits.charAt(num) - '0'];
         for (int i = 0; i < str.length(); i++) {
             temp.append(str.charAt(i));
-            //c
+            //递归，处理下一层
             backTracking(digits, numString, num + 1);
             //剔除末尾的继续尝试
             temp.deleteCharAt(temp.length() - 1);

problems/0019.删除链表的倒数第N个节点.md

@@ -22,10 +22,12 @@
 
 输入：head = [1,2,3,4,5], n = 2
 输出：[1,2,3,5]
+
 示例 2：
 
 输入：head = [1], n = 1
 输出：[]
+
 示例 3：
 
 输入：head = [1,2], n = 1
@@ -111,7 +113,6 @@ class Solution {
         for (int i = 0; i <= n; i++) {
             fastIndex = fastIndex.next;
         }
-
         while (fastIndex != null) {
             fastIndex = fastIndex.next;
             slowIndex = slowIndex.next;
@@ -193,16 +194,18 @@ func removeNthFromEnd(head *ListNode, n int) *ListNode {
  * @param {number} n
  * @return {ListNode}
  */
-var removeNthFromEnd = function(head, n) {
-    let ret = new ListNode(0, head),
-        slow = fast = ret;
-    while(n--) fast = fast.next;
-    while (fast.next !== null) {
-        fast = fast.next; 
-        slow = slow.next
-    };
-    slow.next = slow.next.next;
-    return ret.next;
+var removeNthFromEnd = function (head, n) {
+  // 创建哨兵节点，简化解题逻辑
+  let dummyHead = new ListNode(0, head);
+  let fast = dummyHead;
+  let slow = dummyHead;
+  while (n--) fast = fast.next;
+  while (fast.next !== null) {
+    slow = slow.next;
+    fast = fast.next;
+  }
+  slow.next = slow.next.next;
+  return dummyHead.next;
 };
 ```
 ### TypeScript:

problems/0027.移除元素.md

@@ -476,6 +476,32 @@ public class Solution {
 }
 ```
 
+###Dart:
+```dart
+int removeElement(List<int> nums, int val) {
+    //相向双指针法
+    var left = 0;
+    var right = nums.length - 1;
+    while (left <= right) {
+	//寻找左侧的val，将其被右侧非val覆盖
+        if (nums[left] == val) {
+            while (nums[right] == val&&left<=right) {
+                right--;
+            if (right < 0) {
+                return 0;
+        }
+      }
+      nums[left] = nums[right--];
+    } else {
+      left++;
+    }
+  }
+  //覆盖后可以将0至left部分视为所需部分
+  return left;
+}
+
+```
+
 <p align="center">
 <a href="https://programmercarl.com/other/kstar.html" target="_blank">
   <img src="../pics/网站星球宣传海报.jpg" width="1000"/>

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

@@ -313,18 +313,18 @@ func searchInsert(nums []int, target int) int {
 
 ```rust
 impl Solution {
-    pub fn search_insert(nums: Vec<i32>, target: i32) -> i32 {
-        let mut left = 0;
-        let mut right = nums.len();
-        while left < right {
+      pub fn search_insert(nums: Vec<i32>, target: i32) -> i32 {
+        use std::cmp::Ordering::{Equal, Greater, Less};
+        let (mut left, mut right) = (0, nums.len() as i32 - 1);
+        while left <= right {
             let mid = (left + right) / 2;
-            match nums[mid].cmp(&target) {
-                Ordering::Less => left = mid + 1,
-                Ordering::Equal => return ((left + right) / 2) as i32,
-                Ordering::Greater => right = mid,
+            match nums[mid as usize].cmp(&target) {
+                Less => left = mid + 1,
+                Equal => return mid,
+                Greater => right = mid - 1,
             }
         }
-        ((left + right) / 2) as i32
+        right + 1
     }
 }
 ```

problems/0037.解数独.md

@@ -224,7 +224,7 @@ public:
 
 
 ### Java
-
+解法一:
 ```java
 class Solution {
     public void solveSudoku(char[][] board) {
@@ -291,7 +291,73 @@ class Solution {
     }
 }
 ```
+解法二(bitmap标记)
+```
+class Solution{
+    int[] rowBit = new int[9];
+    int[] colBit = new int[9];
+    int[] square9Bit = new int[9];
+
+    public void solveSudoku(char[][] board) {
+        // 1 10 11
+        for (int y = 0; y < board.length; y++) {
+            for (int x = 0; x < board[y].length; x++) {
+                int numBit = 1 << (board[y][x] - '1');
+                rowBit[y] ^= numBit;
+                colBit[x] ^= numBit;
+                square9Bit[(y / 3) * 3 + x / 3] ^= numBit;
+            }
+        }
+        backtrack(board, 0);
+    }
+
+    public boolean backtrack(char[][] board, int n) {
+        if (n >= 81) {
+            return true;
+        }
+
+        // 快速算出行列编号 n/9 n%9
+        int row = n / 9;
+        int col = n % 9;
+
+        if (board[row][col] != '.') {
+            return backtrack(board, n + 1);
+        }
+
+        for (char c = '1'; c <= '9'; c++) {
+            int numBit = 1 << (c - '1');
+            if (!isValid(numBit, row, col)) continue;
+            {
+                board[row][col] = c;    // 当前的数字放入到数组之中，
+                rowBit[row] ^= numBit; // 第一行rowBit[0],第一个元素eg: 1 , 0^1=1,第一个元素:4, 100^1=101,...
+                colBit[col] ^= numBit;
+                square9Bit[(row / 3) * 3 + col / 3] ^= numBit;
+            }
+            if (backtrack(board, n + 1)) return true;
+            {
+                board[row][col] = '.';    // 不满足条件，回退成'.'
+                rowBit[row] &= ~numBit; // 第一行rowBit[0],第一个元素eg: 1 , 101&=~1==>101&111111110==>100
+                colBit[col] &= ~numBit;
+                square9Bit[(row / 3) * 3 + col / 3] &= ~numBit;
+            }
+        }
+        return false;
+    }
+
 
+    boolean isValid(int numBit, int row, int col) {
+        // 左右
+        if ((rowBit[row] & numBit) > 0) return false;
+        // 上下
+        if ((colBit[col] & numBit) > 0) return false;
+        // 9宫格: 快速算出第n个九宫格,编号[0,8] , 编号=(row / 3) * 3 + col / 3
+        if ((square9Bit[(row / 3) * 3 + col / 3] & numBit) > 0) return false;
+        return true;
+    }
+
+}
+
+```
 ### Python
 
 ```python

problems/0039.组合总和.md

@@ -311,7 +311,7 @@ class Solution:
 
         for i in range(startIndex, len(candidates)):
             if total + candidates[i] > target:
-                continue
+                break
             total += candidates[i]
             path.append(candidates[i])
             self.backtracking(candidates, target, total, i, path, result)

problems/0063.不同路径II.md

@@ -145,7 +145,7 @@ 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
+        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;

problems/0070.爬楼梯完全背包版本.md

@@ -211,10 +211,33 @@ func main() {
 ```
 
 ### JavaScript:
-
+```javaScript
+var climbStairs = function (n) {
+  let dp = new Array(n + 1).fill(0);
+  dp[0] = 1;
+  // 排列题，注意循环顺序，背包在外物品在内
+   for (let j = 1; j <= n; j++) {//遍历背包
+    for (let i = 1; i <= 2; i++) {//遍历物品
+     if (j - i >= 0) dp[j] = dp[j] + dp[j - i];
+    }
+  }
+  return dp[n];
+}
+```
 
 ### TypeScript：
-
+```typescript
+var climbStairs = function (n: number): number {
+    let dp: number[] = new Array(n + 1).fill(0);
+    dp[0] = 1;
+    for (let j = 1; j <= n; j++) {//遍历背包
+        for (let i = 1; i <= 2; i++) {//遍历物品
+            if (j - i >= 0) dp[j] = dp[j] + dp[j - i];
+        }
+    }
+    return dp[n];
+}
+```
 
 ### Rust:
 

problems/0077.组合.md

@@ -469,28 +469,58 @@ func dfs(n int, k int, start int) {
 ```
 
 ### Javascript
+未剪枝：
+
+```js
+var combine = function (n, k) {
+  // 回溯法
+  let result = [],
+    path = [];
+  let backtracking = (_n, _k, startIndex) => {
+    // 终止条件
+    if (path.length === _k) {
+      result.push(path.slice());
+      return;
+    }
+    // 循环本层集合元素
+    for (let i = startIndex; i <= _n; i++) {
+      path.push(i);
+      //   递归
+      backtracking(_n, _k, i + 1);
+      //   回溯操作
+      path.pop();
+    }
+  };
+  backtracking(n, k, 1);
+  return result;
+};
+```
 
 剪枝：
 
 ```javascript
-let result = []
-let path = []
-var combine = function(n, k) {
-  result = []
-  combineHelper(n, k, 1)
-  return result
+var combine = function (n, k) {
+  // 回溯法
+  let result = [],
+    path = [];
+  let backtracking = (_n, _k, startIndex) => {
+    // 终止条件
+    if (path.length === _k) {
+      result.push(path.slice());
+      return;
+    }
+    // 循环本层集合元素
+    for (let i = startIndex; i <= _n - (_k - path.length) + 1; i++) {
+      path.push(i);
+      //   递归
+      backtracking(_n, _k, i + 1);
+      //   回溯操作
+      path.pop();
+    }
+  };
+  backtracking(n, k, 1);
+  return result;
 };
-const combineHelper = (n, k, startIndex) => {
-  if (path.length === k) {
-    result.push([...path])
-    return
-  }
-  for (let i = startIndex; i <= n - (k - path.length) + 1; ++i) {
-    path.push(i)
-    combineHelper(n, k, i + 1)
-    path.pop()
-  }
-}
 ```
 
 ### TypeScript