Merge branch 'master' into master

Author: youngyangyang04

README.md

@@ -299,24 +299,25 @@
 <img src='https://code-thinking.cdn.bcebos.com/pics/动态规划-背包问题总结.png' width=500 alt='背包问题大纲'> </img></div>
 
 
-11. [动态规划：01背包理论基础](./problems/背包理论基础01背包-1.md)
-12. [动态规划：01背包理论基础（滚动数组）](./problems/背包理论基础01背包-2.md)
+11. [动态规划：01背包理论基础（二维dp数组）](./problems/背包理论基础01背包-1.md)
+12. [动态规划：01背包理论基础（一维dp数组）](./problems/背包理论基础01背包-2.md)
 13. [动态规划：416.分割等和子集](./problems/0416.分割等和子集.md)
 14. [动态规划：1049.最后一块石头的重量II](./problems/1049.最后一块石头的重量II.md)
 15. [本周小结！（动态规划系列三）](./problems/周总结/20210121动规周末总结.md)
 16. [动态规划：494.目标和](./problems/0494.目标和.md)
 17. [动态规划：474.一和零](./problems/0474.一和零.md) 
-18. [动态规划：完全背包总结篇](./problems/背包问题理论基础完全背包.md)
-19. [动态规划：518.零钱兑换II](./problems/0518.零钱兑换II.md)
-20. [本周小结！（动态规划系列四）](./problems/周总结/20210128动规周末总结.md)
-21. [动态规划：377.组合总和Ⅳ](./problems/0377.组合总和Ⅳ.md)
-22. [动态规划：70.爬楼梯（完全背包版本）](./problems/0070.爬楼梯完全背包版本.md)
-23. [动态规划：322.零钱兑换](./problems/0322.零钱兑换.md)
-24. [动态规划：279.完全平方数](./problems/0279.完全平方数.md)
-25. [本周小结！（动态规划系列五）](./problems/周总结/20210204动规周末总结.md)
-26. [动态规划：139.单词拆分](./problems/0139.单词拆分.md)
-27. [动态规划：多重背包理论基础](./problems/背包问题理论基础多重背包.md)
-28. [背包问题总结篇](./problems/背包总结篇.md)
+18. [动态规划：完全背包理论基础（二维dp数组）](./problems/背包问题理论基础完全背包.md)
+19. [动态规划：完全背包理论基础（一维dp数组）](./problems/背包问题完全背包一维.md)
+20. [动态规划：518.零钱兑换II](./problems/0518.零钱兑换II.md)
+21. [本周小结！（动态规划系列四）](./problems/周总结/20210128动规周末总结.md)
+22. [动态规划：377.组合总和Ⅳ](./problems/0377.组合总和Ⅳ.md)
+23. [动态规划：70.爬楼梯（完全背包版本）](./problems/0070.爬楼梯完全背包版本.md)
+24. [动态规划：322.零钱兑换](./problems/0322.零钱兑换.md)
+25. [动态规划：279.完全平方数](./problems/0279.完全平方数.md)
+26. [本周小结！（动态规划系列五）](./problems/周总结/20210204动规周末总结.md)
+27. [动态规划：139.单词拆分](./problems/0139.单词拆分.md)
+28. [动态规划：多重背包理论基础](./problems/背包问题理论基础多重背包.md)
+29. [背包问题总结篇](./problems/背包总结篇.md)
 
 打家劫舍系列：
 
@@ -408,21 +409,6 @@
 
 （持续更新中....）
 
-
-## 十大排序
-
-## 数论 
-
-## 高级数据结构经典题目 
-
-* 并查集 
-* 最小生成树 
-* 线段树 
-* 树状数组 
-* 字典树 
-
-## 海量数据处理
-
 # 补充题目
 
 以上题目是重中之重，大家至少要刷两遍以上才能彻底理解，如果熟练以上题目之后还在找其他题目练手，可以再刷以下题目：

problems/0015.三数之和.md

@@ -34,7 +34,7 @@
 
 ### 哈希解法
 
-两层for循环就可以确定 a 和b 的数值了，可以使用哈希法来确定 0-(a+b) 是否在 数组里出现过，其实这个思路是正确的，但是我们有一个非常棘手的问题，就是题目中说的不可以包含重复的三元组。
+两层for循环就可以确定 两个数值，可以使用哈希法来确定 第三个数 0-(a+b) 或者 0 - (a + c)  是否在 数组里出现过，其实这个思路是正确的，但是我们有一个非常棘手的问题，就是题目中说的不可以包含重复的三元组。
 
 把符合条件的三元组放进vector中，然后再去重，这样是非常费时的，很容易超时，也是这道题目通过率如此之低的根源所在。
 
@@ -48,35 +48,41 @@
 ```CPP
 class Solution {
 public:
+ // 在一个数组中找到3个数形成的三元组，它们的和为0，不能重复使用（三数下标互不相同），且三元组不能重复。
+ // b（存储）== 0-(a+c)（检索）
  vector<vector<int>> threeSum(vector<int>& nums) {
  vector<vector<int>> result;
  sort(nums.begin(), nums.end());
- // 找出a + b + c = 0
- // a = nums[i], b = nums[j], c = -(a + b)
+ 
  for (int i = 0; i < nums.size(); i++) {
- // 排序之后如果第一个元素已经大于零，那么不可能凑成三元组
- if (nums[i] > 0) {
+ // 如果a是正数，a<b<c，不可能形成和为0的三元组
+ if (nums[i] > 0)
  break;
- }
- if (i > 0 && nums[i] == nums[i - 1]) { //三元组元素a去重
+ 
+ // [a, a, ...] 如果本轮a和上轮a相同，那么找到的b，c也是相同的，所以去重a
+ if (i > 0 && nums[i] == nums[i - 1])
  continue;
- }
+ 
+ // 这个set的作用是存储b
  unordered_set<int> set;
- for (int j = i + 1; j < nums.size(); j++) {
-  if (j > i + 2
-  && nums[j] == nums[j-1]
-  && nums[j-1] == nums[j-2]) { // 三元组元素b去重
+ 
+ for (int k = i + 1; k < nums.size(); k++) {
+ // 去重b=c时的b和c
+ if (k > i + 2 && nums[k] == nums[k - 1] && nums[k - 1] == nums[k - 2])
  continue;
+ 
+ // a+b+c=0 <=> b=0-(a+c)
+ int target = 0 - (nums[i] + nums[k]);
+ if (set.find(target) != set.end()) {
+ result.push_back({nums[i], target, nums[k]}); // nums[k]成为c
+ set.erase(target);
  }
- int c = 0 - (nums[i] + nums[j]);
- if (set.find(c) != set.end()) {
- result.push_back({nums[i], nums[j], c});
- set.erase(c);// 三元组元素c去重
- } else {
- set.insert(nums[j]);
+ else {
+ set.insert(nums[k]); // nums[k]成为b
  }
  }
  }
+
   return result;
  }
 };

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

@@ -58,7 +58,7 @@
 
 * fast和slow同时移动，直到fast指向末尾，如题：
 <img src='https://code-thinking.cdn.bcebos.com/pics/19.%E5%88%A0%E9%99%A4%E9%93%BE%E8%A1%A8%E7%9A%84%E5%80%92%E6%95%B0%E7%AC%ACN%E4%B8%AA%E8%8A%82%E7%82%B92.png' width=600> </img></div>
-
+//图片中有错别词：应该将“只到”改为“直到”
 * 删除slow指向的下一个节点，如图：
 <img src='https://code-thinking.cdn.bcebos.com/pics/19.%E5%88%A0%E9%99%A4%E9%93%BE%E8%A1%A8%E7%9A%84%E5%80%92%E6%95%B0%E7%AC%ACN%E4%B8%AA%E8%8A%82%E7%82%B93.png' width=600> </img></div>
 

problems/0028.实现strStr.md

@@ -1456,6 +1456,70 @@ public int[] GetNext(string needle)
 }
 ```
 
+### C:
+
+> 前缀表统一右移和减一
+
+```c
+
+int *build_next(char* needle, int len) {
+
+ int *next = (int *)malloc(len * sizeof(int));
+ assert(next); // 确保分配成功
+
+ // 初始化next数组
+ next[0] = -1; // next[0] 设置为 -1，表示没有有效前缀匹配
+ if (len <= 1) { // 如果模式串长度小于等于 1，直接返回
+  return next;
+ }
+ next[1] = 0; // next[1] 设置为 0，表示第一个字符没有公共前后缀
+
+ // 构建next数组， i 从模式串的第三个字符开始， j 指向当前匹配的最长前缀长度
+ int i = 2, j = 0;
+ while (i < len) {
+  if (needle[i - 1] == needle[j]) {
+  j++;
+  next[i] = j;
+  i++;
+  } else if (j > 0) {
+  // 如果不匹配且 j > 0， 回退到次长匹配前缀的长度
+  j = next[j];
+  } else {
+  next[i] = 0;
+  i++;
+  }
+ }
+ return next;
+}
+
+int strStr(char* haystack, char* needle) {
+
+ int needle_len = strlen(needle);
+ int haystack_len = strlen(haystack);
+
+ int *next = build_next(needle, needle_len);
+
+ int i = 0, j = 0; // i 指向主串的当前起始位置, j 指向模式串的当前匹配位置
+ while (i <= haystack_len - needle_len) {
+  if (haystack[i + j] == needle[j]) {
+  j++;
+  if (j == needle_len) {
+  free(next);
+  next = NULL
+  return i;
+  }
+  } else {
+  i += j - next[j]; // 调整主串的起始位置
+  j = j > 0 ? next[j] : 0;
+  }
+ }
+
+ free(next);
+ next = NULL;
+ return -1;
+}
+```
+
 <p align="center">
 <a href="https://programmercarl.com/other/kstar.html" target="_blank">
  <img src="../pics/网站星球宣传海报.jpg" width="1000"/>

problems/0037.解数独.md

@@ -366,40 +366,56 @@ class Solution:
  """
  Do not return anything, modify board in-place instead.
  """
- self.backtracking(board)
-
- def backtracking(self, board: List[List[str]]) -> bool:
- # 若有解，返回True；若无解，返回False
- for i in range(len(board)): # 遍历行
- for j in range(len(board[0])): # 遍历列
- # 若空格内已有数字，跳过
- if board[i][j] != '.': continue
- for k in range(1, 10):
- if self.is_valid(i, j, k, board):
- board[i][j] = str(k)
- if self.backtracking(board): return True
- board[i][j] = '.'
- # 若数字1-9都不能成功填入空格，返回False无解
- return False
- return True # 有解
-
- def is_valid(self, row: int, col: int, val: int, board: List[List[str]]) -> bool:
- # 判断同一行是否冲突
- for i in range(9):
- if board[row][i] == str(val):
- return False
- # 判断同一列是否冲突
- for j in range(9):
- if board[j][col] == str(val):
- return False
- # 判断同一九宫格是否有冲突
- start_row = (row // 3) * 3
- start_col = (col // 3) * 3
- for i in range(start_row, start_row + 3):
- for j in range(start_col, start_col + 3):
- if board[i][j] == str(val):
- return False
- return True
+ row_used = [set() for _ in range(9)]
+ col_used = [set() for _ in range(9)]
+ box_used = [set() for _ in range(9)]
+ for row in range(9):
+ for col in range(9):
+ num = board[row][col]
+ if num == ".":
+ continue
+ row_used[row].add(num)
+ col_used[col].add(num)
+ box_used[(row // 3) * 3 + col // 3].add(num)
+ self.backtracking(0, 0, board, row_used, col_used, box_used)
+
+ def backtracking(
+ self,
+ row: int,
+ col: int,
+ board: List[List[str]],
+ row_used: List[List[int]],
+ col_used: List[List[int]],
+ box_used: List[List[int]],
+ ) -> bool:
+ if row == 9:
+ return True
+
+ next_row, next_col = (row, col + 1) if col < 8 else (row + 1, 0)
+ if board[row][col] != ".":
+ return self.backtracking(
+ next_row, next_col, board, row_used, col_used, box_used
+ )
+
+ for num in map(str, range(1, 10)):
+ if (
+ num not in row_used[row]
+ and num not in col_used[col]
+ and num not in box_used[(row // 3) * 3 + col // 3]
+ ):
+ board[row][col] = num
+ row_used[row].add(num)
+ col_used[col].add(num)
+ box_used[(row // 3) * 3 + col // 3].add(num)
+ if self.backtracking(
+ next_row, next_col, board, row_used, col_used, box_used
+ ):
+ return True
+ board[row][col] = "."
+ row_used[row].remove(num)
+ col_used[col].remove(num)
+ box_used[(row // 3) * 3 + col // 3].remove(num)
+ return False
 ```
 
 ### Go