diff --git a/README.md b/README.md
index 620942dc..3dbf2c0d 100644
--- a/README.md
+++ b/README.md
@@ -4,11 +4,12 @@
> 1. **介绍**：本项目是一套完整的刷题计划，旨在帮助大家少走弯路，循序渐进学算法，[关注作者](#关于作者)
> 2. **PDF版本** ： [「代码随想录」算法精讲 PDF 版本](https://programmercarl.com/other/algo_pdf.html) 。
-> 3. **最强八股文：**：[代码随想录知识星球精华PDF](https://www.programmercarl.com/other/kstar_baguwen.html)
-> 4. **刷题顺序** ： README已经将刷题顺序排好了，按照顺序一道一道刷就可以。
-> 5. **学习社区** : 一起学习打卡/面试技巧/如何选择offer/大厂内推/职场规则/简历修改/技术分享/程序人生。欢迎加入[「代码随想录」知识星球](https://programmercarl.com/other/kstar.html) 。
-> 6. **提交代码**：本项目统一使用C++语言进行讲解，但已经有Java、Python、Go、JavaScript等等多语言版本，感谢[这里的每一位贡献者](https://github.com/youngyangyang04/leetcode-master/graphs/contributors)，如果你也想贡献代码点亮你的头像，[点击这里](https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A)了解提交代码的方式。
-> 7. **转载须知** ：以下所有文章皆为我（[程序员Carl](https://github.com/youngyangyang04)）的原创。引用本项目文章请注明出处，发现恶意抄袭或搬运，会动用法律武器维护自己的权益。让我们一起维护一个良好的技术创作环境！
+> 3. **算法公开课** : [《代码随想录》算法视频公开课](https://www.bilibili.com/video/BV1fA4y1o715) 。
+> 4. **最强八股文：**：[代码随想录知识星球精华PDF](https://www.programmercarl.com/other/kstar_baguwen.html)
+> 5. **刷题顺序** ： README已经将刷题顺序排好了，按照顺序一道一道刷就可以。
+> 6. **学习社区** : 一起学习打卡/面试技巧/如何选择offer/大厂内推/职场规则/简历修改/技术分享/程序人生。欢迎加入[「代码随想录」知识星球](https://programmercarl.com/other/kstar.html) 。
+> 7. **提交代码**：本项目统一使用C++语言进行讲解，但已经有Java、Python、Go、JavaScript等等多语言版本，感谢[这里的每一位贡献者](https://github.com/youngyangyang04/leetcode-master/graphs/contributors)，如果你也想贡献代码点亮你的头像，[点击这里](https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A)了解提交代码的方式。
+> 8. **转载须知** ：以下所有文章皆为我（[程序员Carl](https://github.com/youngyangyang04)）的原创。引用本项目文章请注明出处，发现恶意抄袭或搬运，会动用法律武器维护自己的权益。让我们一起维护一个良好的技术创作环境！
@@ -141,77 +142,77 @@
## 数组
1. [数组过于简单，但你该了解这些！](./problems/数组理论基础.md)
-2. [数组：每次遇到二分法，都是一看就会，一写就废](./problems/0704.二分查找.md)
-3. [数组：就移除个元素很难么？](./problems/0027.移除元素.md)
-4. [数组：有序数组的平方，还有序么？](./problems/0977.有序数组的平方.md)
-5. [数组：滑动窗口拯救了你](./problems/0209.长度最小的子数组.md)
-6. [数组：这个循环可以转懵很多人！](./problems/0059.螺旋矩阵II.md)
+2. [数组：二分查找](./problems/0704.二分查找.md)
+3. [数组：移除元素](./problems/0027.移除元素.md)
+4. [数组：序数组的平方](./problems/0977.有序数组的平方.md)
+5. [数组：长度最小的子数组](./problems/0209.长度最小的子数组.md)
+6. [数组：螺旋矩阵II](./problems/0059.螺旋矩阵II.md)
7. [数组：总结篇](./problems/数组总结篇.md)
## 链表
1. [关于链表，你该了解这些！](./problems/链表理论基础.md)
-2. [链表：听说用虚拟头节点会方便很多？](./problems/0203.移除链表元素.md)
-3. [链表：一道题目考察了常见的五个操作！](./problems/0707.设计链表.md)
-4. [链表：听说过两天反转链表又写不出来了？](./problems/0206.翻转链表.md)
+2. [链表：移除链表元素](./problems/0203.移除链表元素.md)
+3. [链表：设计链表](./problems/0707.设计链表.md)
+4. [链表：翻转链表](./problems/0206.翻转链表.md)
5. [链表：两两交换链表中的节点](./problems/0024.两两交换链表中的节点.md)
6. [链表：删除链表的倒数第 N 个结点](./problems/0019.删除链表的倒数第N个节点.md)
7. [链表：链表相交](./problems/面试题02.07.链表相交.md)
-8. [链表：环找到了，那入口呢？](./problems/0142.环形链表II.md)
+8. [链表：环形链表](./problems/0142.环形链表II.md)
9. [链表：总结篇！](./problems/链表总结篇.md)
## 哈希表
1. [关于哈希表，你该了解这些！](./problems/哈希表理论基础.md)
-2. [哈希表：可以拿数组当哈希表来用，但哈希值不要太大](./problems/0242.有效的字母异位词.md)
+2. [哈希表：有效的字母异位词](./problems/0242.有效的字母异位词.md)
3. [哈希表：查找常用字符](./problems/1002.查找常用字符.md)
-4. [哈希表：哈希值太大了，还是得用set](./problems/0349.两个数组的交集.md)
-5. [哈希表：用set来判断快乐数](./problems/0202.快乐数.md)
-6. [哈希表：map等候多时了](./problems/0001.两数之和.md)
-7. [哈希表：其实需要哈希的地方都能找到map的身影](./problems/0454.四数相加II.md)
-8. [哈希表：这道题目我做过？](./problems/0383.赎金信.md)
-9. [哈希表：解决了两数之和，那么能解决三数之和么？](./problems/0015.三数之和.md)
-10. [双指针法：一样的道理，能解决四数之和](./problems/0018.四数之和.md)
-11. [哈希表：总结篇！（每逢总结必经典）](./problems/哈希表总结.md)
+4. [哈希表：两个数组的交集](./problems/0349.两个数组的交集.md)
+5. [哈希表：快乐数](./problems/0202.快乐数.md)
+6. [哈希表：两数之和](./problems/0001.两数之和.md)
+7. [哈希表：四数相加II](./problems/0454.四数相加II.md)
+8. [哈希表：赎金信](./problems/0383.赎金信.md)
+9. [哈希表：三数之和](./problems/0015.三数之和.md)
+10. [双指针法：四数之和](./problems/0018.四数之和.md)
+11. [哈希表：总结篇！](./problems/哈希表总结.md)
## 字符串
-1. [字符串：这道题目，使用库函数一行代码搞定](./problems/0344.反转字符串.md)
-2. [字符串：简单的反转还不够！](./problems/0541.反转字符串II.md)
+1. [字符串：反转字符串](./problems/0344.反转字符串.md)
+2. [字符串：反转字符串II](./problems/0541.反转字符串II.md)
3. [字符串：替换空格](./problems/剑指Offer05.替换空格.md)
-4. [字符串：花式反转还不够！](./problems/0151.翻转字符串里的单词.md)
-5. [字符串：反转个字符串还有这个用处？](./problems/剑指Offer58-II.左旋转字符串.md)
+4. [字符串：翻转字符串里的单词](./problems/0151.翻转字符串里的单词.md)
+5. [字符串：左旋转字符串](./problems/剑指Offer58-II.左旋转字符串.md)
6. [帮你把KMP算法学个通透](./problems/0028.实现strStr.md)
-8. [字符串：KMP算法还能干这个！](./problems/0459.重复的子字符串.md)
+8. [字符串：重复的子字符串](./problems/0459.重复的子字符串.md)
9. [字符串：总结篇！](./problems/字符串总结.md)
## 双指针法
双指针法基本都是应用在数组，字符串与链表的题目上
-1. [数组：就移除个元素很难么？](./problems/0027.移除元素.md)
-2. [字符串：这道题目，使用库函数一行代码搞定](./problems/0344.反转字符串.md)
+1. [数组：移除元素](./problems/0027.移除元素.md)
+2. [字符串：反转字符串](./problems/0344.反转字符串.md)
3. [字符串：替换空格](./problems/剑指Offer05.替换空格.md)
-4. [字符串：花式反转还不够！](./problems/0151.翻转字符串里的单词.md)
-5. [链表：听说过两天反转链表又写不出来了？](./problems/0206.翻转链表.md)
+4. [字符串：翻转字符串里的单词](./problems/0151.翻转字符串里的单词.md)
+5. [链表：翻转链表](./problems/0206.翻转链表.md)
6. [链表：删除链表的倒数第 N 个结点](./problems/0019.删除链表的倒数第N个节点.md)
7. [链表：链表相交](./problems/面试题02.07.链表相交.md)
-8. [链表：环找到了，那入口呢？](./problems/0142.环形链表II.md)
-9. [哈希表：解决了两数之和，那么能解决三数之和么？](./problems/0015.三数之和.md)
-10. [双指针法：一样的道理，能解决四数之和](./problems/0018.四数之和.md)
-11. [双指针法：总结篇！](./problems/双指针总结.md)
+8. [链表：环形链表](./problems/0142.环形链表II.md)
+9. [双指针：三数之和](./problems/0015.三数之和.md)
+10. [双指针：四数之和](./problems/0018.四数之和.md)
+11. [双指针：总结篇！](./problems/双指针总结.md)
## 栈与队列
1. [栈与队列：来看看栈和队列不为人知的一面](./problems/栈与队列理论基础.md)
-2. [栈与队列：我用栈来实现队列怎么样？](./problems/0232.用栈实现队列.md)
-3. [栈与队列：用队列实现栈还有点别扭](./problems/0225.用队列实现栈.md)
-4. [栈与队列：系统中处处都是栈的应用](./problems/0020.有效的括号.md)
-5. [栈与队列：匹配问题都是栈的强项](./problems/1047.删除字符串中的所有相邻重复项.md)
-6. [栈与队列：有没有想过计算机是如何处理表达式的？](./problems/0150.逆波兰表达式求值.md)
-7. [栈与队列：滑动窗口里求最大值引出一个重要数据结构](./problems/0239.滑动窗口最大值.md)
-8. [栈与队列：求前 K 个高频元素和队列有啥关系？](./problems/0347.前K个高频元素.md)
+2. [栈与队列：用栈实现队列](./problems/0232.用栈实现队列.md)
+3. [栈与队列：用队列实现栈](./problems/0225.用队列实现栈.md)
+4. [栈与队列：有效的括号](./problems/0020.有效的括号.md)
+5. [栈与队列：删除字符串中的所有相邻重复项](./problems/1047.删除字符串中的所有相邻重复项.md)
+6. [栈与队列：逆波兰表达式求值](./problems/0150.逆波兰表达式求值.md)
+7. [栈与队列：滑动窗口最大值](./problems/0239.滑动窗口最大值.md)
+8. [栈与队列：前K个高频元素](./problems/0347.前K个高频元素.md)
9. [栈与队列：总结篇！](./problems/栈与队列总结.md)
## 二叉树
@@ -220,34 +221,34 @@
1. [关于二叉树，你该了解这些！](./problems/二叉树理论基础.md)
-2. [二叉树：一入递归深似海，从此offer是路人](./problems/二叉树的递归遍历.md)
-3. [二叉树：听说递归能做的，栈也能做！](./problems/二叉树的迭代遍历.md)
-4. [二叉树：前中后序迭代方式的写法就不能统一一下么？](./problems/二叉树的统一迭代法.md)
-5. [二叉树：层序遍历登场！](./problems/0102.二叉树的层序遍历.md)
-6. [二叉树：你真的会翻转二叉树么？](./problems/0226.翻转二叉树.md)
+2. [二叉树：二叉树的递归遍历](./problems/二叉树的递归遍历.md)
+3. [二叉树：二叉树的迭代遍历](./problems/二叉树的迭代遍历.md)
+4. [二叉树：二叉树的统一迭代法](./problems/二叉树的统一迭代法.md)
+5. [二叉树：二叉树的层序遍历](./problems/0102.二叉树的层序遍历.md)
+6. [二叉树：翻转二叉树](./problems/0226.翻转二叉树.md)
7. [本周小结！（二叉树）](./problems/周总结/20200927二叉树周末总结.md)
-8. [二叉树：我对称么？](./problems/0101.对称二叉树.md)
-9. [二叉树：看看这些树的最大深度](./problems/0104.二叉树的最大深度.md)
-10. [二叉树：看看这些树的最小深度](./problems/0111.二叉树的最小深度.md)
-11. [二叉树：我有多少个节点？](./problems/0222.完全二叉树的节点个数.md)
-12. [二叉树：我平衡么？](./problems/0110.平衡二叉树.md)
-13. [二叉树：找我的所有路径？](./problems/0257.二叉树的所有路径.md)
+8. [二叉树：对称二叉树](./problems/0101.对称二叉树.md)
+9. [二叉树：二叉树的最大深度](./problems/0104.二叉树的最大深度.md)
+10. [二叉树：二叉树的最小深度](./problems/0111.二叉树的最小深度.md)
+11. [二叉树：完全二叉树的节点个数](./problems/0222.完全二叉树的节点个数.md)
+12. [二叉树：平衡二叉树](./problems/0110.平衡二叉树.md)
+13. [二叉树：二叉树的所有路径](./problems/0257.二叉树的所有路径.md)
14. [本周总结！二叉树系列二](./problems/周总结/20201003二叉树周末总结.md)
-15. [二叉树：以为使用了递归，其实还隐藏着回溯](./problems/二叉树中递归带着回溯.md)
-16. [二叉树：做了这么多题目了，我的左叶子之和是多少？](./problems/0404.左叶子之和.md)
-17. [二叉树：我的左下角的值是多少？](./problems/0513.找树左下角的值.md)
+15. [二叉树：二叉树中递归带着回溯](./problems/二叉树中递归带着回溯.md)
+16. [二叉树：左叶子之和](./problems/0404.左叶子之和.md)
+17. [二叉树：找树左下角的值](./problems/0513.找树左下角的值.md)
18. [二叉树：路径总和](./problems/0112.路径总和.md)
-19. [二叉树：构造二叉树登场！](./problems/0106.从中序与后序遍历序列构造二叉树.md)
-20. [二叉树：构造一棵最大的二叉树](./problems/0654.最大二叉树.md)
+19. [二叉树：构造二叉树](./problems/0106.从中序与后序遍历序列构造二叉树.md)
+20. [二叉树：最大二叉树](./problems/0654.最大二叉树.md)
21. [本周小结！（二叉树系列三）](./problems/周总结/20201010二叉树周末总结.md)
22. [二叉树：合并两个二叉树](./problems/0617.合并二叉树.md)
23. [二叉树：二叉搜索树登场！](./problems/0700.二叉搜索树中的搜索.md)
-24. [二叉树：我是不是一棵二叉搜索树](./problems/0098.验证二叉搜索树.md)
+24. [二叉树：验证二叉搜索树](./problems/0098.验证二叉搜索树.md)
25. [二叉树：搜索树的最小绝对差](./problems/0530.二叉搜索树的最小绝对差.md)
-26. [二叉树：我的众数是多少？](./problems/0501.二叉搜索树中的众数.md)
+26. [二叉树：二叉搜索树中的众数](./problems/0501.二叉搜索树中的众数.md)
27. [二叉树：公共祖先问题](./problems/0236.二叉树的最近公共祖先.md)
28. [本周小结！（二叉树系列四）](./problems/周总结/20201017二叉树周末总结.md)
-29. [二叉树：搜索树的公共祖先问题](./problems/0235.二叉搜索树的最近公共祖先.md)
+29. [二叉树：搜索树的最近公共祖先](./problems/0235.二叉搜索树的最近公共祖先.md)
30. [二叉树：搜索树中的插入操作](./problems/0701.二叉搜索树中的插入操作.md)
31. [二叉树：搜索树中的删除操作](./problems/0450.删除二叉搜索树中的节点.md)
32. [二叉树：修剪一棵搜索树](./problems/0669.修剪二叉搜索树.md)
@@ -500,25 +501,6 @@
[各类基础算法模板](https://github.com/youngyangyang04/leetcode/blob/master/problems/算法模板.md)
-
-
-# B站算法视频讲解
-
-以下为[B站「代码随想录」](https://space.bilibili.com/525438321)算法讲解视频：
-
-* [KMP算法（理论篇）](https://www.bilibili.com/video/BV1PD4y1o7nd)
-* [KMP算法（代码篇）](https://www.bilibili.com/video/BV1M5411j7Xx)
-* [回溯算法理论基础](https://www.bilibili.com/video/BV1cy4y167mM)
-* [回溯算法之组合问题（力扣题目：77.组合）](https://www.bilibili.com/video/BV1ti4y1L7cv)
-* [组合问题的剪枝操作（对应力扣题目：77.组合）](https://www.bilibili.com/video/BV1wi4y157er)
-* [组合总和（对应力扣题目：39.组合总和）](https://www.bilibili.com/video/BV1KT4y1M7HJ/)
-* [分割回文串（对应力扣题目：131.分割回文串)](https://www.bilibili.com/video/BV1c54y1e7k6)
-* [二叉树理论基础](https://www.bilibili.com/video/BV1Hy4y1t7ij)
-* [二叉树的递归遍历](https://www.bilibili.com/video/BV1Wh411S7xt)
-* [二叉树的非递归遍历（一）](https://www.bilibili.com/video/BV15f4y1W7i2)
-
-（持续更新中....）
-
# 贡献者
[点此这里](https://github.com/youngyangyang04/leetcode-master/graphs/contributors)查看LeetCode-Master的所有贡献者。感谢他们补充了LeetCode-Master的其他语言版本，让更多的读者收益于此项目。
diff --git a/problems/0001.两数之和.md b/problems/0001.两数之和.md
index a15e1349..5bedd0a0 100644
--- a/problems/0001.两数之和.md
+++ b/problems/0001.两数之和.md
@@ -263,13 +263,15 @@ php
```php
function twoSum(array $nums, int $target): array
{
- for ($i = 0; $i < count($nums);$i++) {
- // 计算剩下的数
- $residue = $target - $nums[$i];
- // 匹配的index，有则返回index， 无则返回false
- $match_index = array_search($residue, $nums);
- if ($match_index !== false && $match_index != $i) {
- return array($i, $match_index);
+ $map = [];
+ foreach($nums as $i => $num) {
+ if (isset($map[$target - $num])) {
+ return [
+ $i,
+ $map[$target - $num]
+ ];
+ } else {
+ $map[$num] = $i;
}
}
return [];
diff --git a/problems/0018.四数之和.md b/problems/0018.四数之和.md
index d6b55fd6..ea7502b1 100644
--- a/problems/0018.四数之和.md
+++ b/problems/0018.四数之和.md
@@ -74,7 +74,7 @@ public:
sort(nums.begin(), nums.end());
for (int k = 0; k < nums.size(); k++) {
// 剪枝处理
- if (nums[k] > target && nums[k] >= 0 && target >= 0) {
+ if (nums[k] > target && nums[k] >= 0) {
break; // 这里使用break，统一通过最后的return返回
}
// 对nums[k]去重
@@ -83,7 +83,7 @@ public:
}
for (int i = k + 1; i < nums.size(); i++) {
// 2级剪枝处理
- if (nums[k] + nums[i] > target && nums[k] + nums[i] >= 0 && target >= 0) {
+ if (nums[k] + nums[i] > target && nums[k] + nums[i] >= 0) {
break;
}
diff --git a/problems/0019.删除链表的倒数第N个节点.md b/problems/0019.删除链表的倒数第N个节点.md
index 62fe4f8b..00caeea0 100644
--- a/problems/0019.删除链表的倒数第N个节点.md
+++ b/problems/0019.删除链表的倒数第N个节点.md
@@ -33,6 +33,9 @@
## 思路
+《代码随想录》算法公开课：[链表遍历学清楚！ | LeetCode：19.删除链表倒数第N个节点](https://www.bilibili.com/video/BV1vW4y1U7Gf)，相信结合视频在看本篇题解，更有助于大家对链表的理解。
+
+
双指针的经典应用，如果要删除倒数第n个节点，让fast移动n步，然后让fast和slow同时移动，直到fast指向链表末尾。删掉slow所指向的节点就可以了。
思路是这样的，但要注意一些细节。
diff --git a/problems/0020.有效的括号.md b/problems/0020.有效的括号.md
index eaf0a719..3c7da61b 100644
--- a/problems/0020.有效的括号.md
+++ b/problems/0020.有效的括号.md
@@ -41,6 +41,9 @@
# 思路
+《代码随想录》算法视频公开课：[栈的拿手好戏！| LeetCode：20. 有效的括号](https://www.bilibili.com/video/BV1AF411w78g)，相信结合视频在看本篇题解，更有助于大家对链表的理解。
+
+
## 题外话
**括号匹配是使用栈解决的经典问题。**
@@ -79,8 +82,10 @@ cd a/b/c/../../
1. 第一种情况，字符串里左方向的括号多余了 ，所以不匹配。
+
2. 第二种情况，括号没有多余，但是 括号的类型没有匹配上。
+
3. 第三种情况，字符串里右方向的括号多余了，所以不匹配。
@@ -110,7 +115,8 @@ cd a/b/c/../../
class Solution {
public:
bool isValid(string s) {
- stack st;
+ if (s.size() % 2 != 0) return false; // 如果s的长度为奇数，一定不符合要求
+ stack st;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '(') st.push(')');
else if (s[i] == '{') st.push('}');
@@ -124,6 +130,7 @@ public:
return st.empty();
}
};
+
```
技巧性的东西没有固定的学习方法，还是要多看多练，自己灵活运用了。
diff --git a/problems/0024.两两交换链表中的节点.md b/problems/0024.两两交换链表中的节点.md
index 4b4b39e7..905a0539 100644
--- a/problems/0024.两两交换链表中的节点.md
+++ b/problems/0024.两两交换链表中的节点.md
@@ -18,7 +18,8 @@
## 思路
-针对本题重点难点，我录制了B站讲解视频，[帮你把链表细节学清楚！ | LeetCode：24. 两两交换链表中的节点](https://www.bilibili.com/video/BV1YT411g7br)，相信结合视频在看本篇题解，更有助于大家对链表的理解。
+《代码随想录》算法公开课：[帮你把链表细节学清楚！ | LeetCode：24. 两两交换链表中的节点](https://www.bilibili.com/video/BV1YT411g7br)，相信结合视频在看本篇题解，更有助于大家对链表的理解。
+
这道题目正常模拟就可以了。
diff --git a/problems/0031.下一个排列.md b/problems/0031.下一个排列.md
index ada9deba..a33821b8 100644
--- a/problems/0031.下一个排列.md
+++ b/problems/0031.下一个排列.md
@@ -178,10 +178,10 @@ class Solution:
>另一种思路
```python
class Solution:
- '''
- 抛砖引玉：因题目要求“必须原地修改，只允许使用额外常数空间”，python内置sorted函数以及数组切片+sort()无法使用。
- 故选择另一种算法暂且提供一种python思路
- '''
+ '''
+ 抛砖引玉：因题目要求“必须原地修改，只允许使用额外常数空间”，python内置sorted函数以及数组切片+sort()无法使用。
+ 故选择另一种算法暂且提供一种python思路
+ '''
def nextPermutation(self, nums: List[int]) -> None:
"""
Do not return anything, modify nums in-place instead.
@@ -195,9 +195,9 @@ class Solution:
break
self.reverse(nums, i, length-1)
break
- else:
- # 若正常结束循环，则对原数组直接翻转
- self.reverse(nums, 0, length-1)
+ if n == 1:
+ # 若正常结束循环，则对原数组直接翻转
+ self.reverse(nums, 0, length-1)
def reverse(self, nums: List[int], low: int, high: int) -> None:
while low < high:
diff --git a/problems/0037.解数独.md b/problems/0037.解数独.md
index 626e9d97..8b196890 100644
--- a/problems/0037.解数独.md
+++ b/problems/0037.解数独.md
@@ -488,6 +488,52 @@ function solveSudoku(board: string[][]): void {
};
```
+### Rust
+
+```Rust
+impl Solution {
+ fn is_valid(row: usize, col: usize, val: char, board: &mut Vec>) -> bool{
+ for i in 0..9 {
+ if board[row][i] == val { return false; }
+ }
+ for j in 0..9 {
+ if board[j][col] == val {
+ return false;
+ }
+ }
+ let start_row = (row / 3) * 3;
+ let start_col = (col / 3) * 3;
+ for i in start_row..(start_row + 3) {
+ for j in start_col..(start_col + 3) {
+ if board[i][j] == val { return false; }
+ }
+ }
+ return true;
+ }
+
+ fn backtracking(board: &mut Vec>) -> bool{
+ for i in 0..board.len() {
+ for j in 0..board[0].len() {
+ if board[i][j] != '.' { continue; }
+ for k in '1'..='9' {
+ if Self::is_valid(i, j, k, board) {
+ board[i][j] = k;
+ if Self::backtracking(board) { return true; }
+ board[i][j] = '.';
+ }
+ }
+ return false;
+ }
+ }
+ return true;
+ }
+
+ pub fn solve_sudoku(board: &mut Vec>) {
+ Self::backtracking(board);
+ }
+}
+```
+
### C
```C
diff --git a/problems/0045.跳跃游戏II.md b/problems/0045.跳跃游戏II.md
index 648355fd..13142c99 100644
--- a/problems/0045.跳跃游戏II.md
+++ b/problems/0045.跳跃游戏II.md
@@ -305,6 +305,56 @@ object Solution {
}
```
+### Rust
+
+```Rust
+//版本一
+impl Solution {
+ fn max(a: i32, b:i32) -> i32 {
+ if a > b { a } else { b }
+ }
+ pub fn jump(nums: Vec) -> i32 {
+ if nums.len() == 0 { return 0; }
+ let mut cur_distance: i32 = 0;
+ let mut ans: i32 = 0;
+ let mut next_distance: i32 = 0;
+ for i in 0..nums.len() {
+ next_distance = Self::max(nums[i] + i as i32, next_distance);
+ if i as i32 == cur_distance {
+ if cur_distance != (nums.len() - 1) as i32 {
+ ans += 1;
+ cur_distance = next_distance;
+ if next_distance == (nums.len() - 1) as i32 { break; }
+ }
+ else { break; }
+ }
+ }
+ ans
+ }
+}
+```
+
+```Rust
+//版本二
+impl Solution {
+ fn max(a: i32, b:i32) -> i32 {
+ if a > b { a } else { b }
+ }
+ pub fn jump(nums: Vec) -> i32 {
+ let mut cur_distance: i32 = 0;
+ let mut ans: i32 = 0;
+ let mut next_distance: i32 = 0;
+ for i in 0..nums.len() - 1 {
+ next_distance = Self::max(nums[i] + i as i32, next_distance);
+ if i as i32 == cur_distance {
+ cur_distance = next_distance;
+ ans += 1;
+ }
+ }
+ ans
+ }
+}
+```
-----------------------
diff --git a/problems/0051.N皇后.md b/problems/0051.N皇后.md
index 9ae1f975..77a2ca59 100644
--- a/problems/0051.N皇后.md
+++ b/problems/0051.N皇后.md
@@ -558,6 +558,56 @@ func solveNQueens(_ n: Int) -> [[String]] {
}
```
+### Rust
+
+```Rust
+impl Solution {
+ fn is_valid(row: usize, col: usize, chessboard: &mut Vec>, n: usize) -> bool {
+ let mut i = 0 as usize;
+ while i < row {
+ if chessboard[i][col] == 'Q' { return false; }
+ i += 1;
+ }
+ let (mut i, mut j) = (row as i32 - 1, col as i32 - 1);
+ while i >= 0 && j >= 0 {
+ if chessboard[i as usize][j as usize] == 'Q' { return false; }
+ i -= 1;
+ j -= 1;
+ }
+ let (mut i, mut j) = (row as i32 - 1, col as i32 + 1);
+ while i >= 0 && j < n as i32 {
+ if chessboard[i as usize][j as usize] == 'Q' { return false; }
+ i -= 1;
+ j += 1;
+ }
+ return true;
+ }
+ fn backtracking(result: &mut Vec>, n: usize, row: usize, chessboard: &mut Vec>) {
+ if row == n {
+ let mut chessboard_clone: Vec = Vec::new();
+ for i in chessboard {
+ chessboard_clone.push(i.iter().collect::());
+ }
+ result.push(chessboard_clone);
+ return;
+ }
+ for col in 0..n {
+ if Self::is_valid(row, col, chessboard, n) {
+ chessboard[row][col] = 'Q';
+ Self::backtracking(result, n, row + 1, chessboard);
+ chessboard[row][col] = '.';
+ }
+ }
+ }
+ pub fn solve_n_queens(n: i32) -> Vec> {
+ let mut result: Vec> = Vec::new();
+ let mut chessboard: Vec> = vec![vec!['.'; n as usize]; n as usize];
+ Self::backtracking(&mut result, n as usize, 0, &mut chessboard);
+ result
+ }
+}
+```
+
### C
```c
char ***ans;
diff --git a/problems/0053.最大子序和（动态规划）.md b/problems/0053.最大子序和（动态规划）.md
index 228ceade..00f3eb84 100644
--- a/problems/0053.最大子序和（动态规划）.md
+++ b/problems/0053.最大子序和（动态规划）.md
@@ -4,7 +4,7 @@
参与本项目，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！
-## 53. 最大子序和
+# 53. 最大子序和
[力扣题目链接](https://leetcode.cn/problems/maximum-subarray/)
diff --git a/problems/0054.螺旋矩阵.md b/problems/0054.螺旋矩阵.md
index 8f2691fe..efbda5ff 100644
--- a/problems/0054.螺旋矩阵.md
+++ b/problems/0054.螺旋矩阵.md
@@ -132,69 +132,6 @@ public:
* [剑指Offer 29.顺时针打印矩阵](https://leetcode.cn/problems/shun-shi-zhen-da-yin-ju-zhen-lcof/)
## 其他语言版本
-Python:
-```python
-class Solution:
- def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
- m, n = len(matrix), len(matrix[0])
- left, right, up, down = 0, n - 1, 0, m - 1 # 定位四个方向的边界，闭区间
- res = []
-
- while True:
- for i in range(left, right + 1): # 上边，从左到右
- res.append(matrix[up][i])
- up += 1 # 上边界下移
- if len(res) >= m * n: # 判断是否已经遍历完
- break
-
- for i in range(up, down + 1): # 右边，从上到下
- res.append(matrix[i][right])
- right -= 1 # 右边界左移
-
- if len(res) >= m * n:
- break
-
- for i in range(right, left - 1, -1): # 下边，从右到左
- res.append(matrix[down][i])
- down -= 1 # 下边界上移
-
- if len(res) >= m * n:
- break
-
- for i in range(down, up - 1, -1): # 左边，从下到上
- res.append(matrix[i][left])
- left += 1 # 左边界右移
-
- if len(res) >= m * n:
- break
-
- return res
-```
-```python3
-class Solution:
- def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
- r=len(matrix)
- if r == 0 or len(matrix[0])==0:
- return []
- c=len(matrix[0])
- res=matrix[0]
-
- if r>1:
- for i in range (1,r):
- res.append(matrix[i][c-1])
- for j in range(c-2, -1, -1):
- res.append(matrix[r-1][j])
- if c>1:
- for i in range(r-2, 0, -1):
- res.append(matrix[i][0])
-
- M=[]
- for k in range(1, r-1):
- e=matrix[k][1:-1]
- M.append(e)
-
- return res+self.spiralOrder(M)
-```
-----------------------
参与本项目，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！
-## 72. 编辑距离
+# 72. 编辑距离
[力扣题目链接](https://leetcode.cn/problems/edit-distance/)
diff --git a/problems/0100.相同的树.md b/problems/0100.相同的树.md
index 210418f7..4b6eb7aa 100644
--- a/problems/0100.相同的树.md
+++ b/problems/0100.相同的树.md
@@ -240,6 +240,20 @@ Go：
JavaScript：
+> 递归法
+
+```javascript
+var isSameTree = function (p, q) {
+ if (p == null && q == null)
+ return true;
+ if (p == null || q == null)
+ return false;
+ if (p.val != q.val)
+ return false;
+ return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
+};
+```
+
TypeScript:
> 递归法-先序遍历
diff --git a/problems/0102.二叉树的层序遍历.md b/problems/0102.二叉树的层序遍历.md
index 5ef23944..9ad34494 100644
--- a/problems/0102.二叉树的层序遍历.md
+++ b/problems/0102.二叉树的层序遍历.md
@@ -205,6 +205,36 @@ class Solution {
go:
+```go
+/**
+102. 二叉树的递归遍历
+ */
+func levelOrder(root *TreeNode) [][]int {
+ arr := [][]int{}
+
+ depth := 0
+
+ var order func(root *TreeNode, depth int)
+
+ order = func(root *TreeNode, depth int) {
+ if root == nil {
+ return
+ }
+ if len(arr) == depth {
+ arr = append(arr, []int{})
+ }
+ arr[depth] = append(arr[depth], root.Val)
+
+ order(root.Left, depth+1)
+ order(root.Right, depth+1)
+ }
+
+ order(root, depth)
+
+ return arr
+}
+```
+
```go
/**
102. 二叉树的层序遍历
diff --git a/problems/0115.不同的子序列.md b/problems/0115.不同的子序列.md
index 9ae04139..fe76c3ed 100644
--- a/problems/0115.不同的子序列.md
+++ b/problems/0115.不同的子序列.md
@@ -4,7 +4,7 @@
参与本项目，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！
-## 115.不同的子序列
+# 115.不同的子序列
[力扣题目链接](https://leetcode.cn/problems/distinct-subsequences/)
diff --git a/problems/0121.买卖股票的最佳时机.md b/problems/0121.买卖股票的最佳时机.md
index a577f1dd..868c0e3e 100644
--- a/problems/0121.买卖股票的最佳时机.md
+++ b/problems/0121.买卖股票的最佳时机.md
@@ -4,7 +4,7 @@
参与本项目，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！
-## 121. 买卖股票的最佳时机
+# 121. 买卖股票的最佳时机
[力扣题目链接](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock/)
diff --git a/problems/0122.买卖股票的最佳时机II.md b/problems/0122.买卖股票的最佳时机II.md
index e4742cf0..1094d9e4 100644
--- a/problems/0122.买卖股票的最佳时机II.md
+++ b/problems/0122.买卖股票的最佳时机II.md
@@ -282,6 +282,43 @@ function maxProfit(prices: number[]): number {
};
```
+### Rust
+
+贪心：
+```Rust
+impl Solution {
+ fn max(a: i32, b: i32) -> i32 {
+ if a > b { a } else { b }
+ }
+ pub fn max_profit(prices: Vec) -> i32 {
+ let mut result = 0;
+ for i in 1..prices.len() {
+ result += Self::max(prices[i] - prices[i - 1], 0);
+ }
+ result
+ }
+}
+```
+
+动态规划：
+```Rust
+impl Solution {
+ fn max(a: i32, b: i32) -> i32 {
+ if a > b { a } else { b }
+ }
+ pub fn max_profit(prices: Vec) -> i32 {
+ let n = prices.len();
+ let mut dp = vec![vec![0; 2]; n];
+ dp[0][0] -= prices[0];
+ for i in 1..n {
+ dp[i][0] = Self::max(dp[i - 1][0], dp[i - 1][1] - prices[i]);
+ dp[i][1] = Self::max(dp[i - 1][1], dp[i - 1][0] + prices[i]);
+ }
+ Self::max(dp[n - 1][0], dp[n - 1][1])
+ }
+}
+```
+
### C:
贪心：
```c
diff --git a/problems/0122.买卖股票的最佳时机II（动态规划）.md b/problems/0122.买卖股票的最佳时机II（动态规划）.md
index fa9f8842..98bf3e52 100644
--- a/problems/0122.买卖股票的最佳时机II（动态规划）.md
+++ b/problems/0122.买卖股票的最佳时机II（动态规划）.md
@@ -4,7 +4,7 @@
参与本项目，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！
-## 122.买卖股票的最佳时机II
+# 122.买卖股票的最佳时机II
[力扣题目链接](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-ii/)
diff --git a/problems/0123.买卖股票的最佳时机III.md b/problems/0123.买卖股票的最佳时机III.md
index c15aaee8..947e6947 100644
--- a/problems/0123.买卖股票的最佳时机III.md
+++ b/problems/0123.买卖股票的最佳时机III.md
@@ -4,7 +4,7 @@
参与本项目，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！
-## 123.买卖股票的最佳时机III
+# 123.买卖股票的最佳时机III
[力扣题目链接](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-iii/)
diff --git a/problems/0134.加油站.md b/problems/0134.加油站.md
index 7e4f74f0..4e698d1b 100644
--- a/problems/0134.加油站.md
+++ b/problems/0134.加油站.md
@@ -405,6 +405,55 @@ function canCompleteCircuit(gas: number[], cost: number[]): number {
};
```
+### Rust
+
+贪心算法：方法一
+
+```Rust
+impl Solution {
+ pub fn can_complete_circuit(gas: Vec, cost: Vec) -> i32 {
+ let mut cur_sum = 0;
+ let mut min = i32::MAX;
+ for i in 0..gas.len() {
+ let rest = gas[i] - cost[i];
+ cur_sum += rest;
+ if cur_sum < min { min = cur_sum; }
+ }
+ if cur_sum < 0 { return -1; }
+ if min > 0 { return 0; }
+ for i in (0..gas.len()).rev() {
+ let rest = gas[i] - cost[i];
+ min += rest;
+ if min >= 0 { return i as i32; }
+ }
+ -1
+ }
+}
+```
+
+贪心算法：方法二
+
+```Rust
+impl Solution {
+ pub fn can_complete_circuit(gas: Vec, cost: Vec) -> i32 {
+ let mut cur_sum = 0;
+ let mut total_sum = 0;
+ let mut start = 0;
+ for i in 0..gas.len() {
+ cur_sum += gas[i] - cost[i];
+ total_sum += gas[i] - cost[i];
+ if cur_sum < 0 {
+ start = i + 1;
+ cur_sum = 0;
+ }
+ }
+ if total_sum < 0 { return -1; }
+ start as i32
+ }
+}
+```
+
+
### C
贪心算法：方法一
diff --git a/problems/0142.环形链表II.md b/problems/0142.环形链表II.md
index 0b9059dc..2054fd35 100644
--- a/problems/0142.环形链表II.md
+++ b/problems/0142.环形链表II.md
@@ -24,7 +24,8 @@
## 思路
-为了易于大家理解，我录制讲解视频：[B站：把环形链表讲清楚！ ](https://www.bilibili.com/video/BV1if4y1d7ob)。结合视频在看本篇题解，事半功倍。
+《代码随想录》算法公开课：[把环形链表讲清楚！| LeetCode:142.环形链表II](https://www.bilibili.com/video/BV1if4y1d7ob)，相信结合视频在看本篇题解，更有助于大家对链表的理解。
+
这道题目，不仅考察对链表的操作，而且还需要一些数学运算。
diff --git a/problems/0188.买卖股票的最佳时机IV.md b/problems/0188.买卖股票的最佳时机IV.md
index 7ff19852..8319fcba 100644
--- a/problems/0188.买卖股票的最佳时机IV.md
+++ b/problems/0188.买卖股票的最佳时机IV.md
@@ -4,7 +4,7 @@
参与本项目，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！
-## 188.买卖股票的最佳时机IV
+# 188.买卖股票的最佳时机IV
[力扣题目链接](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-iv/)
diff --git a/problems/0198.打家劫舍.md b/problems/0198.打家劫舍.md
index ad660f27..6428359c 100644
--- a/problems/0198.打家劫舍.md
+++ b/problems/0198.打家劫舍.md
@@ -4,7 +4,7 @@
参与本项目，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！
-## 198.打家劫舍
+# 198.打家劫舍
[力扣题目链接](https://leetcode.cn/problems/house-robber/)
diff --git a/problems/0213.打家劫舍II.md b/problems/0213.打家劫舍II.md
index d6b53a24..7ae7aae0 100644
--- a/problems/0213.打家劫舍II.md
+++ b/problems/0213.打家劫舍II.md
@@ -4,7 +4,7 @@
参与本项目，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！
-## 213.打家劫舍II
+# 213.打家劫舍II
[力扣题目链接](https://leetcode.cn/problems/house-robber-ii/)
diff --git a/problems/0225.用队列实现栈.md b/problems/0225.用队列实现栈.md
index 17c50cd9..fb2851f1 100644
--- a/problems/0225.用队列实现栈.md
+++ b/problems/0225.用队列实现栈.md
@@ -28,6 +28,10 @@
# 思路
+
+《代码随想录》算法公开课：[队列的基本操作！ | LeetCode：225. 用队列实现栈](https://www.bilibili.com/video/BV1Fd4y1K7sm)，相信结合视频在看本篇题解，更有助于大家对链表的理解。
+
+
（这里要强调是单向队列）
有的同学可能疑惑这种题目有什么实际工程意义，**其实很多算法题目主要是对知识点的考察和教学意义远大于其工程实践的意义，所以面试题也是这样！**
diff --git a/problems/0232.用栈实现队列.md b/problems/0232.用栈实现队列.md
index 4dc7b794..7364e6c1 100644
--- a/problems/0232.用栈实现队列.md
+++ b/problems/0232.用栈实现队列.md
@@ -38,6 +38,9 @@ queue.empty(); // 返回 false
## 思路
+《代码随想录》算法公开课：[栈的基本操作！ | LeetCode：232.用栈实现队列](https://www.bilibili.com/video/BV1nY4y1w7VC)，相信结合视频在看本篇题解，更有助于大家对链表的理解。
+
+
这是一道模拟题，不涉及到具体算法，考察的就是对栈和队列的掌握程度。
使用栈来模式队列的行为，如果仅仅用一个栈，是一定不行的，所以需要两个栈**一个输入栈，一个输出栈**，这里要注意输入栈和输出栈的关系。
@@ -170,14 +173,6 @@ class MyQueue {
}
}
-/**
- * Your MyQueue object will be instantiated and called as such:
- * MyQueue obj = new MyQueue();
- * obj.push(x);
- * int param_2 = obj.pop();
- * int param_3 = obj.peek();
- * boolean param_4 = obj.empty();
- */
```
diff --git a/problems/0239.滑动窗口最大值.md b/problems/0239.滑动窗口最大值.md
index 474b3a75..6ec98506 100644
--- a/problems/0239.滑动窗口最大值.md
+++ b/problems/0239.滑动窗口最大值.md
@@ -36,7 +36,7 @@
难点是如何求一个区间里的最大值呢？ （这好像是废话），暴力一下不就得了。
-暴力方法，遍历一遍的过程中每次从窗口中在找到最大的数值，这样很明显是$O(n × k)$的算法。
+暴力方法，遍历一遍的过程中每次从窗口中在找到最大的数值，这样很明显是O(n × k)的算法。
有的同学可能会想用一个大顶堆（优先级队列）来存放这个窗口里的k个数字，这样就可以知道最大的最大值是多少了， **但是问题是这个窗口是移动的，而大顶堆每次只能弹出最大值，我们无法移除其他数值，这样就造成大顶堆维护的不是滑动窗口里面的数值了。所以不能用大顶堆。**
@@ -183,13 +183,13 @@ public:
};
```
-在来看一下时间复杂度，使用单调队列的时间复杂度是 $O(n)$。
+在来看一下时间复杂度，使用单调队列的时间复杂度是 O(n)。
-有的同学可能想了，在队列中 push元素的过程中，还有pop操作呢，感觉不是纯粹的$O(n)$。
+有的同学可能想了，在队列中 push元素的过程中，还有pop操作呢，感觉不是纯粹的O(n)。
-其实，大家可以自己观察一下单调队列的实现，nums 中的每个元素最多也就被 push_back 和 pop_back 各一次，没有任何多余操作，所以整体的复杂度还是 $O(n)$。
+其实，大家可以自己观察一下单调队列的实现，nums 中的每个元素最多也就被 push_back 和 pop_back 各一次，没有任何多余操作，所以整体的复杂度还是 O(n)。
-空间复杂度因为我们定义一个辅助队列，所以是$O(k)$。
+空间复杂度因为我们定义一个辅助队列，所以是O(k)。
# 扩展
diff --git a/problems/0300.最长上升子序列.md b/problems/0300.最长上升子序列.md
index 41c6a7ce..9e256897 100644
--- a/problems/0300.最长上升子序列.md
+++ b/problems/0300.最长上升子序列.md
@@ -4,7 +4,7 @@
参与本项目，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！
-## 300.最长递增子序列
+# 300.最长递增子序列
[力扣题目链接](https://leetcode.cn/problems/longest-increasing-subsequence/)
diff --git a/problems/0309.最佳买卖股票时机含冷冻期.md b/problems/0309.最佳买卖股票时机含冷冻期.md
index 3791a71f..45772181 100644
--- a/problems/0309.最佳买卖股票时机含冷冻期.md
+++ b/problems/0309.最佳买卖股票时机含冷冻期.md
@@ -4,7 +4,7 @@
参与本项目，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！
-## 309.最佳买卖股票时机含冷冻期
+# 309.最佳买卖股票时机含冷冻期
[力扣题目链接](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-with-cooldown/)
diff --git a/problems/0332.重新安排行程.md b/problems/0332.重新安排行程.md
index 71942c79..8b5f797d 100644
--- a/problems/0332.重新安排行程.md
+++ b/problems/0332.重新安排行程.md
@@ -742,5 +742,33 @@ func (p ticketSlice) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
```
+### Rust
+** 文中的Hashmap嵌套Hashmap的方法因为Rust的所有权问题暂时无法实现，此方法为删除哈希表中元素法 **
+```Rust
+use std::collections::HashMap;
+impl Solution {
+ fn backtracking(airport: String, targets: &mut HashMap<&String, Vec<&String>>, result: &mut Vec) {
+ while let Some(next_airport) = targets.get_mut(&airport).unwrap_or(&mut vec![]).pop() {
+ Self::backtracking(next_airport.clone(), targets, result);
+ }
+ result.push(airport.clone());
+ }
+
+ pub fn find_itinerary(tickets: Vec>) -> Vec {
+ let mut targets: HashMap<&String, Vec<&String>> = HashMap::new();
+ let mut result = Vec::new();
+ for t in 0..tickets.len() {
+ targets.entry(&tickets[t][0]).or_default().push(&tickets[t][1]);
+ }
+ for (_, target) in targets.iter_mut() {
+ target.sort_by(|a, b| b.cmp(a));
+ }
+ Self::backtracking("JFK".to_string(), &mut targets, &mut result);
+ result.reverse();
+ result
+ }
+}
+```
+
-----------------------
diff --git a/problems/0337.打家劫舍III.md b/problems/0337.打家劫舍III.md
index d2add232..20b458e9 100644
--- a/problems/0337.打家劫舍III.md
+++ b/problems/0337.打家劫舍III.md
@@ -5,7 +5,7 @@
参与本项目，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！
-## 337.打家劫舍 III
+# 337.打家劫舍 III
[力扣题目链接](https://leetcode.cn/problems/house-robber-iii/)
@@ -190,9 +190,9 @@ public:
if (cur == NULL) return vector{0, 0};
vector left = robTree(cur->left);
vector right = robTree(cur->right);
- // 偷cur
- int val1 = cur->val + left[0] + right[0];
- // 不偷cur
+ // 偷cur，那么就不能偷左右节点。
+ int val1 = cur->val + left[1] + right[1];
+ // 不偷cur，那么可以偷也可以不偷左右节点，则取较大的情况
int val2 = max(left[0], left[1]) + max(right[0], right[1]);
return {val2, val1};
}
@@ -353,18 +353,30 @@ class Solution:
# self.left = left
# self.right = right
class Solution:
- def rob(self, root: TreeNode) -> int:
- result = self.rob_tree(root)
- return max(result[0], result[1])
-
- def rob_tree(self, node):
- if node is None:
- return (0, 0) # (偷当前节点金额，不偷当前节点金额)
- left = self.rob_tree(node.left)
- right = self.rob_tree(node.right)
- val1 = node.val + left[1] + right[1] # 偷当前节点，不能偷子节点
- val2 = max(left[0], left[1]) + max(right[0], right[1]) # 不偷当前节点，可偷可不偷子节点
- return (val1, val2)
+ def rob(self, root: Optional[TreeNode]) -> int:
+ # dp数组（dp table）以及下标的含义：
+ # 1. 下标为 0 记录 **不偷该节点** 所得到的的最大金钱
+ # 2. 下标为 1 记录 **偷该节点** 所得到的的最大金钱
+ dp = self.traversal(root)
+ return max(dp)
+
+ # 要用后序遍历, 因为要通过递归函数的返回值来做下一步计算
+ def traversal(self, node):
+
+ # 递归终止条件，就是遇到了空节点，那肯定是不偷的
+ if not node:
+ return (0, 0)
+
+ left = self.traversal(node.left)
+ right = self.traversal(node.right)
+
+ # 不偷当前节点, 偷子节点
+ val_0 = max(left[0], left[1]) + max(right[0], right[1])
+
+ # 偷当前节点, 不偷子节点
+ val_1 = node.val + left[0] + right[0]
+
+ return (val_0, val_1)
```
### Go
diff --git a/problems/0392.判断子序列.md b/problems/0392.判断子序列.md
index dedeb0ad..9dbafe19 100644
--- a/problems/0392.判断子序列.md
+++ b/problems/0392.判断子序列.md
@@ -5,7 +5,7 @@
参与本项目，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！
-## 392.判断子序列
+# 392.判断子序列
[力扣题目链接](https://leetcode.cn/problems/is-subsequence/)
diff --git a/problems/0406.根据身高重建队列.md b/problems/0406.根据身高重建队列.md
index 827b7481..75e0c40c 100644
--- a/problems/0406.根据身高重建队列.md
+++ b/problems/0406.根据身高重建队列.md
@@ -290,6 +290,26 @@ var reconstructQueue = function(people) {
};
```
+### Rust
+
+```Rust
+impl Solution {
+ pub fn reconstruct_queue(people: Vec>) -> Vec> {
+ let mut people = people;
+ people.sort_by(|a, b| {
+ if a[0] == b[0] { return a[1].cmp(&b[1]); }
+ b[0].cmp(&a[0])
+ });
+ let mut que: Vec> = Vec::new();
+ que.push(people[0].clone());
+ for i in 1..people.len() {
+ let position = people[i][1];
+ que.insert(position as usize, people[i].clone());
+ }
+ que
+ }
+}
+```
### C
```c
diff --git a/problems/0435.无重叠区间.md b/problems/0435.无重叠区间.md
index 3aa4eeb6..6f88cad4 100644
--- a/problems/0435.无重叠区间.md
+++ b/problems/0435.无重叠区间.md
@@ -374,7 +374,26 @@ object Solution {
}
```
+### Rust
+```Rust
+impl Solution {
+ pub fn erase_overlap_intervals(intervals: Vec>) -> i32 {
+ if intervals.len() == 0 { return 0; }
+ let mut intervals = intervals;
+ intervals.sort_by(|a, b| a[1].cmp(&b[1]));
+ let mut count = 1;
+ let mut end = intervals[0][1];
+ for i in 1..intervals.len() {
+ if end <= intervals[i][0] {
+ end = intervals[i][1];
+ count += 1;
+ }
+ }
+ intervals.len() as i32 - count
+ }
+}
+```
-----------------------
diff --git a/problems/0452.用最少数量的箭引爆气球.md b/problems/0452.用最少数量的箭引爆气球.md
index 7b5f387d..c571a235 100644
--- a/problems/0452.用最少数量的箭引爆气球.md
+++ b/problems/0452.用最少数量的箭引爆气球.md
@@ -150,6 +150,7 @@ class Solution {
int count = 1;
//重叠气球的最小右边界
int leftmostRightBound = points[0][1];
+ for (int i = 1; i < points.length; i++) {
//如果下一个气球的左边界大于最小右边界
for(int i = 1; i < points.length; i++){
if (points[i][0] > leftmostRightBound ) {
diff --git a/problems/0459.重复的子字符串.md b/problems/0459.重复的子字符串.md
index 3d6df872..69f71ee3 100644
--- a/problems/0459.重复的子字符串.md
+++ b/problems/0459.重复的子字符串.md
@@ -31,13 +31,16 @@
# 思路
+针对本题，我录制了视频讲解：[字符串这么玩，可有点难度！ | LeetCode：459.重复的子字符串](https://www.bilibili.com/video/BV1cg41127fw)，结合本题解一起看，事半功倍！
+
+
暴力的解法， 就是一个for循环获取 子串的终止位置， 然后判断子串是否能重复构成字符串，又嵌套一个for循环，所以是O(n^2)的时间复杂度。
有的同学可以想，怎么一个for循环就可以获取子串吗？ 至少得一个for获取子串起始位置，一个for获取子串结束位置吧。
其实我们只需要判断，以第一个字母为开始的子串就可以，所以一个for循环获取子串的终止位置就行了。 而且遍历的时候 都不用遍历结束，只需要遍历到中间位置，因为子串结束位置大于中间位置的话，一定不能重复组成字符串。
-暴力的解法，这里就不讲了。
+暴力的解法，这里就不详细讲解了。
主要讲一讲移动匹配 和 KMP两种方法。
diff --git a/problems/0516.最长回文子序列.md b/problems/0516.最长回文子序列.md
index 60d5e920..378f9b74 100644
--- a/problems/0516.最长回文子序列.md
+++ b/problems/0516.最长回文子序列.md
@@ -4,7 +4,8 @@
参与本项目，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！
-## 516.最长回文子序列
+# 516.最长回文子序列
+
[力扣题目链接](https://leetcode.cn/problems/longest-palindromic-subsequence/)
给定一个字符串 s ，找到其中最长的回文子序列，并返回该序列的长度。可以假设 s 的最大长度为 1000 。
diff --git a/problems/0583.两个字符串的删除操作.md b/problems/0583.两个字符串的删除操作.md
index 0e02e721..36c175c3 100644
--- a/problems/0583.两个字符串的删除操作.md
+++ b/problems/0583.两个字符串的删除操作.md
@@ -4,7 +4,7 @@
参与本项目，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！
-## 583. 两个字符串的删除操作
+# 583. 两个字符串的删除操作
[力扣题目链接](https://leetcode.cn/problems/delete-operation-for-two-strings/)
diff --git a/problems/0647.回文子串.md b/problems/0647.回文子串.md
index fa9bf7b8..69efe7d0 100644
--- a/problems/0647.回文子串.md
+++ b/problems/0647.回文子串.md
@@ -4,7 +4,7 @@
参与本项目，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！
-## 647. 回文子串
+# 647. 回文子串
[力扣题目链接](https://leetcode.cn/problems/palindromic-substrings/)
diff --git a/problems/0674.最长连续递增序列.md b/problems/0674.最长连续递增序列.md
index 7e4d0c19..c197e897 100644
--- a/problems/0674.最长连续递增序列.md
+++ b/problems/0674.最长连续递增序列.md
@@ -4,7 +4,7 @@
参与本项目，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！
-## 674. 最长连续递增序列
+# 674. 最长连续递增序列
[力扣题目链接](https://leetcode.cn/problems/longest-continuous-increasing-subsequence/)
diff --git a/problems/0714.买卖股票的最佳时机含手续费（动态规划）.md b/problems/0714.买卖股票的最佳时机含手续费（动态规划）.md
index 7734450e..6e4a86eb 100644
--- a/problems/0714.买卖股票的最佳时机含手续费（动态规划）.md
+++ b/problems/0714.买卖股票的最佳时机含手续费（动态规划）.md
@@ -4,7 +4,7 @@
参与本项目，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！
-## 714.买卖股票的最佳时机含手续费
+# 714.买卖股票的最佳时机含手续费
[力扣题目链接](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-with-transaction-fee/)
diff --git a/problems/0718.最长重复子数组.md b/problems/0718.最长重复子数组.md
index 6de8b80f..d45f9111 100644
--- a/problems/0718.最长重复子数组.md
+++ b/problems/0718.最长重复子数组.md
@@ -4,7 +4,7 @@
参与本项目，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！
-## 718. 最长重复子数组
+# 718. 最长重复子数组
[力扣题目链接](https://leetcode.cn/problems/maximum-length-of-repeated-subarray/)
diff --git a/problems/0763.划分字母区间.md b/problems/0763.划分字母区间.md
index ecf064d3..a6066ebc 100644
--- a/problems/0763.划分字母区间.md
+++ b/problems/0763.划分字母区间.md
@@ -343,6 +343,34 @@ object Solution {
}
```
+### Rust
+
+```Rust
+use std::collections::HashMap;
+impl Solution {
+ fn max (a: usize, b: usize) -> usize {
+ if a > b { a } else { b }
+ }
+ pub fn partition_labels(s: String) -> Vec {
+ let s = s.chars().collect::>();
+ let mut hash: HashMap = HashMap::new();
+ for i in 0..s.len() {
+ hash.insert(s[i], i);
+ }
+ let mut result: Vec = Vec::new();
+ let mut left: usize = 0;
+ let mut right: usize = 0;
+ for i in 0..s.len() {
+ right = Self::max(right, hash[&s[i]]);
+ if i == right {
+ result.push((right - left + 1) as i32);
+ left = i + 1;
+ }
+ }
+ result
+ }
+}
+```
-----------------------
diff --git a/problems/0860.柠檬水找零.md b/problems/0860.柠檬水找零.md
index 42e8b19a..16b89ff7 100644
--- a/problems/0860.柠檬水找零.md
+++ b/problems/0860.柠檬水找零.md
@@ -251,6 +251,38 @@ var lemonadeChange = function(bills) {
};
```
+
+### Rust
+
+```Rust
+impl Solution {
+ pub fn lemonade_change(bills: Vec) -> bool {
+ let mut five = 0;
+ let mut ten = 0;
+ // let mut twenty = 0;
+ for bill in bills {
+ if bill == 5 { five += 1; }
+ if bill == 10 {
+ if five <= 0 { return false; }
+ ten += 1;
+ five -= 1;
+ }
+ if bill == 20 {
+ if five > 0 && ten > 0 {
+ five -= 1;
+ ten -= 1;
+ // twenty += 1;
+ } else if five >= 3 {
+ five -= 3;
+ // twenty += 1;
+ } else { return false; }
+ }
+ }
+ true
+ }
+}
+```
+
### C
```c
bool lemonadeChange(int* bills, int billsSize){
diff --git a/problems/1005.K次取反后最大化的数组和.md b/problems/1005.K次取反后最大化的数组和.md
index 8d721b9f..9d82bf9f 100644
--- a/problems/1005.K次取反后最大化的数组和.md
+++ b/problems/1005.K次取反后最大化的数组和.md
@@ -227,6 +227,31 @@ var largestSumAfterKNegations = function(nums, k) {
};
```
+### Rust
+
+```Rust
+impl Solution {
+ pub fn largest_sum_after_k_negations(nums: Vec, k: i32) -> i32 {
+ let mut nums = nums;
+ let mut k = k;
+ let len = nums.len();
+ nums.sort_by(|a, b| b.abs().cmp(&a.abs()));
+ for i in 0..len {
+ if nums[i] < 0 && k > 0 {
+ nums[i] *= -1;
+ k -= 1;
+ }
+ }
+ if k % 2 == 1 { nums[len - 1] *= -1; }
+ let mut result = 0;
+ for num in nums {
+ result += num;
+ }
+ result
+ }
+}
+```
+
### C
```c
diff --git a/problems/1035.不相交的线.md b/problems/1035.不相交的线.md
index 83ccb08c..831b60c8 100644
--- a/problems/1035.不相交的线.md
+++ b/problems/1035.不相交的线.md
@@ -4,7 +4,7 @@
参与本项目，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！
-## 1035.不相交的线
+# 1035.不相交的线
[力扣题目链接](https://leetcode.cn/problems/uncrossed-lines/)
diff --git a/problems/1047.删除字符串中的所有相邻重复项.md b/problems/1047.删除字符串中的所有相邻重复项.md
index 2c51bbb3..e22c747a 100644
--- a/problems/1047.删除字符串中的所有相邻重复项.md
+++ b/problems/1047.删除字符串中的所有相邻重复项.md
@@ -32,34 +32,21 @@
# 思路
-## 题外话
-
-这道题目就像是我们玩过的游戏对对碰，如果相同的元素放在挨在一起就要消除。
-
-可能我们在玩游戏的时候感觉理所当然应该消除，但程序又怎么知道该如果消除呢，特别是消除之后又有新的元素可能挨在一起。
-
-此时游戏的后端逻辑就可以用一个栈来实现（我没有实际考察对对碰或者爱消除游戏的代码实现，仅从原理上进行推断）。
-
-游戏开发可能使用栈结构，编程语言的一些功能实现也会使用栈结构，实现函数递归调用就需要栈，但不是每种编程语言都支持递归，例如：
-
-
-
-**递归的实现就是：每一次递归调用都会把函数的局部变量、参数值和返回地址等压入调用栈中**，然后递归返回的时候，从栈顶弹出上一次递归的各项参数，所以这就是递归为什么可以返回上一层位置的原因。
-
-相信大家应该遇到过一种错误就是栈溢出，系统输出的异常是`Segmentation fault`（当然不是所有的`Segmentation fault` 都是栈溢出导致的） ，如果你使用了递归，就要想一想是不是无限递归了，那么系统调用栈就会溢出。
-
-而且**在企业项目开发中，尽量不要使用递归！**在项目比较大的时候，由于参数多，全局变量等等，使用递归很容易判断不充分return的条件，非常容易无限递归（或者递归层级过深），**造成栈溢出错误（这种问题还不好排查！）**
-
-好了，题外话over，我们进入正题。
+《代码随想录》算法视频公开课：[栈的好戏还要继续！| LeetCode：1047. 删除字符串中的所有相邻重复项](https://www.bilibili.com/video/BV12a411P7mw)，相信结合视频在看本篇题解，更有助于大家对本题的理解。
## 正题
-本题要删除相邻相同元素，其实也是匹配问题，相同左元素相当于左括号，相同右元素就是相当于右括号，匹配上了就删除。
+本题要删除相邻相同元素，相对于[20. 有效的括号](https://programmercarl.com/0020.%E6%9C%89%E6%95%88%E7%9A%84%E6%8B%AC%E5%8F%B7.html)来说其实也是匹配问题，20. 有效的括号 是匹配左右括号，本题是匹配相邻元素，最后都是做消除的操作。
-那么再来看一下本题：可以把字符串顺序放到一个栈中，然后如果相同的话 栈就弹出，这样最后栈里剩下的元素都是相邻不相同的元素了。
+本题也是用栈来解决的经典题目。
+那么栈里应该放的是什么元素呢？
-如动画所示：
+我们在删除相邻重复项的时候，其实就是要知道当前遍历的这个元素，我们在前一位是不是遍历过一样数值的元素，那么如何记录前面遍历过的元素呢？
+
+所以就是用栈来存放，那么栈的目的，就是存放遍历过的元素，当遍历当前的这个元素的时候，去栈里看一下我们是不是遍历过相同数值的相邻元素。
+
+然后再去做对应的消除操作。 如动画所示：
@@ -113,6 +100,22 @@ public:
};
```
+## 题外话
+
+这道题目就像是我们玩过的游戏对对碰，如果相同的元素放在挨在一起就要消除。
+
+可能我们在玩游戏的时候感觉理所当然应该消除，但程序又怎么知道该如果消除呢，特别是消除之后又有新的元素可能挨在一起。
+
+此时游戏的后端逻辑就可以用一个栈来实现（我没有实际考察对对碰或者爱消除游戏的代码实现，仅从原理上进行推断）。
+
+游戏开发可能使用栈结构，编程语言的一些功能实现也会使用栈结构，实现函数递归调用就需要栈，但不是每种编程语言都支持递归，例如：
+
+**递归的实现就是：每一次递归调用都会把函数的局部变量、参数值和返回地址等压入调用栈中**，然后递归返回的时候，从栈顶弹出上一次递归的各项参数，所以这就是递归为什么可以返回上一层位置的原因。
+
+相信大家应该遇到过一种错误就是栈溢出，系统输出的异常是`Segmentation fault`（当然不是所有的`Segmentation fault` 都是栈溢出导致的） ，如果你使用了递归，就要想一想是不是无限递归了，那么系统调用栈就会溢出。
+
+而且**在企业项目开发中，尽量不要使用递归**！在项目比较大的时候，由于参数多，全局变量等等，使用递归很容易判断不充分return的条件，非常容易无限递归（或者递归层级过深），**造成栈溢出错误（这种问题还不好排查！）**
+
## 其他语言版本
@@ -195,7 +198,7 @@ class Solution {
Python：
```python
-# 方法一，使用栈，推荐！
+# 方法一，使用栈
class Solution:
def removeDuplicates(self, s: str) -> str:
res = list()
diff --git a/problems/1143.最长公共子序列.md b/problems/1143.最长公共子序列.md
index 4f4cb32a..097dc6e6 100644
--- a/problems/1143.最长公共子序列.md
+++ b/problems/1143.最长公共子序列.md
@@ -4,7 +4,7 @@
参与本项目，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！
-## 1143.最长公共子序列
+# 1143.最长公共子序列
[力扣题目链接](https://leetcode.cn/problems/longest-common-subsequence/)
diff --git a/problems/前序/ACM模式如何构建二叉树.md b/problems/前序/ACM模式如何构建二叉树.md
index f2aafed6..01d5b255 100644
--- a/problems/前序/ACM模式如何构建二叉树.md
+++ b/problems/前序/ACM模式如何构建二叉树.md
@@ -57,11 +57,18 @@ TreeNode* construct_binary_tree(const vector& vec) {
if (i == 0) root = node;
}
// 遍历一遍，根据规则左右孩子赋值就可以了
- // 注意这里 结束规则是 i * 2 + 2 < vec.size()，避免空指针
- for (int i = 0; i * 2 + 2 < vec.size(); i++) {
+ // 注意这里 结束规则是 i * 2 + 1 < vec.size()，避免空指针
+ // 为什么结束规则不能是i * 2 + 2 < arr.length呢?
+ // 如果i * 2 + 2 < arr.length 是结束条件
+ // 那么i * 2 + 1这个符合条件的节点就被忽略掉了
+ // 例如[2,7,9,-1,1,9,6,-1,-1,10] 这样的一个二叉树,最后的10就会被忽略掉
+ // 遍历一遍，根据规则左右孩子赋值就可以了
+
+ for (int i = 0; i * 2 + 1 < vec.size(); i++) {
if (vecTree[i] != NULL) {
// 线性存储转连式存储关键逻辑
vecTree[i]->left = vecTree[i * 2 + 1];
+ if(i * 2 + 2 < vec.size())
vecTree[i]->right = vecTree[i * 2 + 2];
}
}
@@ -114,9 +121,10 @@ TreeNode* construct_binary_tree(const vector& vec) {
vecTree[i] = node;
if (i == 0) root = node;
}
- for (int i = 0; i * 2 + 2 < vec.size(); i++) {
+ for (int i = 0; i * 2 + 1 < vec.size(); i++) {
if (vecTree[i] != NULL) {
vecTree[i]->left = vecTree[i * 2 + 1];
+ if(i * 2 + 2 < vec.size())
vecTree[i]->right = vecTree[i * 2 + 2];
}
}
@@ -213,7 +221,7 @@ public class Solution {
static class TreeNode {
// 节点值
int val;
-
+
// 左节点
TreeNode left;
@@ -249,12 +257,18 @@ public class Solution {
}
}
// 遍历一遍，根据规则左右孩子赋值就可以了
- // 注意这里 结束规则是 i * 2 + 2 < arr.length，避免空指针
- for (int i = 0; i * 2 + 2 < arr.length; i++) {
+ // 注意这里 结束规则是 i * 2 + 1 < arr.length，避免空指针
+ // 为什么结束规则不能是i * 2 + 2 < arr.length呢?
+ // 如果i * 2 + 2 < arr.length 是结束条件
+ // 那么i * 2 + 1这个符合条件的节点就被忽略掉了
+ // 例如[2,7,9,-1,1,9,6,-1,-1,10] 这样的一个二叉树,最后的10就会被忽略掉
+ for (int i = 0; i * 2 + 1 < arr.length; i++) {
TreeNode node = treeNodeList.get(i);
if (node != null) {
// 线性存储转连式存储关键逻辑
node.left = treeNodeList.get(2 * i + 1);
+ // 再次判断下 不忽略任何一个节点
+ if(i * 2 + 2 < arr.length)
node.right = treeNodeList.get(2 * i + 2);
}
}
diff --git a/problems/前序/深圳互联网公司总结.md b/problems/前序/深圳互联网公司总结.md
index 3d548abb..f8c07016 100644
--- a/problems/前序/深圳互联网公司总结.md
+++ b/problems/前序/深圳互联网公司总结.md
@@ -22,7 +22,7 @@
* 深信服（总部深圳）
* 大疆（总部深圳，无人机巨头）
* 一加手机（总部深圳）
-* 柔宇科技（国内领先的柔性屏幕制造商，最近正在准备上市）
+* 柔宇科技（最近口碑急转直下）
## 二线大厂
@@ -66,7 +66,7 @@
## 其他行业（有软件/互联网业务）
* 三大电信运营商：中国移动、中国电信、中国联通
-* 房产企业：恒大、万科
+* 房产企业：恒大（暴雷）、万科
* 中信深圳
* 广发证券，深交所
* 珍爱网（珍爱网是国内知名的婚恋服务网站之一）
diff --git a/problems/剑指Offer58-II.左旋转字符串.md b/problems/剑指Offer58-II.左旋转字符串.md
index de4a9030..bf5d3f90 100644
--- a/problems/剑指Offer58-II.左旋转字符串.md
+++ b/problems/剑指Offer58-II.左旋转字符串.md
@@ -263,6 +263,13 @@ function reverseLeftWords(s: string, n: number): string {
return strArr.join('');
};
```
+方法二:
+```typescript
+// 拼接两个字符串，截取符合要求的部分
+function reverseLeftWords(s: string, n: number): string {
+ return (s+s).slice(n,s.length+n);
+};
+```
Swift:
diff --git a/problems/动态规划-股票问题总结篇.md b/problems/动态规划-股票问题总结篇.md
index 47a9b34b..366810e5 100644
--- a/problems/动态规划-股票问题总结篇.md
+++ b/problems/动态规划-股票问题总结篇.md
@@ -4,6 +4,8 @@
参与本项目，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！
+# Leetcode股票问题总结篇!
+
之前我们已经把力扣上股票系列的题目都讲过的，但没有来一篇股票总结，来帮大家高屋建瓴，所以总结篇这就来了！
diff --git a/problems/动态规划总结篇.md b/problems/动态规划总结篇.md
index 847baa9a..45bd3916 100644
--- a/problems/动态规划总结篇.md
+++ b/problems/动态规划总结篇.md
@@ -5,6 +5,7 @@
参与本项目，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！
+# 动态规划最强总结篇！
如今动态规划已经讲解了42道经典题目，共50篇文章，是时候做一篇总结了。
diff --git a/problems/背包问题理论基础完全背包.md b/problems/背包问题理论基础完全背包.md
index fc4609a6..44f7d30d 100644
--- a/problems/背包问题理论基础完全背包.md
+++ b/problems/背包问题理论基础完全背包.md
@@ -3,6 +3,8 @@
参与本项目，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！
+
+
# 动态规划：关于完全背包，你该了解这些！
## 完全背包