mirror of
https://github.com/youngyangyang04/leetcode-master.git
synced 2025-07-06 07:06:42 +08:00
Merge branch 'master' into master
This commit is contained in:
程序员Carl
42
README.md
42
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 @@
|
||||
|
||||
（持续更新中....）
|
||||
|
||||
|
||||
## 十大排序
|
||||
|
||||
## 数论
|
||||
|
||||
## 高级数据结构经典题目
|
||||
|
||||
* 并查集
|
||||
* 最小生成树
|
||||
* 线段树
|
||||
* 树状数组
|
||||
* 字典树
|
||||
|
||||
## 海量数据处理
|
||||
|
||||
# 补充题目
|
||||
|
||||
以上题目是重中之重，大家至少要刷两遍以上才能彻底理解，如果熟练以上题目之后还在找其他题目练手，可以再刷以下题目：
|
||||
|
||||
@ -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;
|
||||
}
|
||||
};
|
||||
|
||||
@ -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>
|
||||
|
||||
|
||||
@ -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"/>
|
||||
|
||||
@ -366,40 +366,56 @@ class Solution:
|
||||
"""
|
||||
Do not return anything, modify board in-place instead.
|
||||
"""
|
||||
self.backtracking(board)
|
||||
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, 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 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
|
||||
|
||||
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
|
||||
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
|
||||
|
||||
@ -474,7 +474,128 @@ class Solution:
|
||||
|
||||
### Go:
|
||||
|
||||
> 单调栈
|
||||
暴力解法
|
||||
|
||||
```go
|
||||
func largestRectangleArea(heights []int) int {
|
||||
sum := 0
|
||||
for i := 0; i < len(heights); i++ {
|
||||
left, right := i, i
|
||||
for left >= 0 {
|
||||
if heights[left] < heights[i] {
|
||||
break
|
||||
}
|
||||
left--
|
||||
}
|
||||
for right < len(heights) {
|
||||
if heights[right] < heights[i] {
|
||||
break
|
||||
}
|
||||
right++
|
||||
}
|
||||
w := right - left - 1
|
||||
h := heights[i]
|
||||
sum = max(sum, w * h)
|
||||
}
|
||||
return sum
|
||||
}
|
||||
|
||||
func max(x, y int) int {
|
||||
if x > y {
|
||||
return x
|
||||
}
|
||||
return y
|
||||
}
|
||||
```
|
||||
|
||||
双指针解法
|
||||
|
||||
```go
|
||||
func largestRectangleArea(heights []int) int {
|
||||
size := len(heights)
|
||||
minLeftIndex := make([]int, size)
|
||||
minRightIndex := make([]int, size)
|
||||
|
||||
// 记录每个柱子 左边第一个小于该柱子的下标
|
||||
minLeftIndex[0] = -1 // 注意这里初始化，防止下面while死循环
|
||||
for i := 1; i < size; i++ {
|
||||
t := i - 1
|
||||
// 这里不是用if，而是不断向左寻找的过程
|
||||
for t >= 0 && heights[t] >= heights[i] {
|
||||
t = minLeftIndex[t]
|
||||
}
|
||||
minLeftIndex[i] = t
|
||||
}
|
||||
// 记录每个柱子 右边第一个小于该柱子的下标
|
||||
minRightIndex[size - 1] = size; // 注意这里初始化，防止下面while死循环
|
||||
for i := size - 2; i >= 0; i-- {
|
||||
t := i + 1
|
||||
// 这里不是用if，而是不断向右寻找的过程
|
||||
for t < size && heights[t] >= heights[i] {
|
||||
t = minRightIndex[t]
|
||||
}
|
||||
minRightIndex[i] = t
|
||||
}
|
||||
// 求和
|
||||
result := 0
|
||||
for i := 0; i < size; i++ {
|
||||
sum := heights[i] * (minRightIndex[i] - minLeftIndex[i] - 1)
|
||||
result = max(sum, result)
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
func max(x, y int) int {
|
||||
if x > y {
|
||||
return x
|
||||
}
|
||||
return y
|
||||
}
|
||||
```
|
||||
|
||||
单调栈
|
||||
|
||||
```go
|
||||
func largestRectangleArea(heights []int) int {
|
||||
result := 0
|
||||
heights = append([]int{0}, heights...) // 数组头部加入元素0
|
||||
heights = append(heights, 0) // 数组尾部加入元素0
|
||||
st := []int{0}
|
||||
|
||||
// 第一个元素已经入栈，从下标1开始
|
||||
for i := 1; i < len(heights); i++ {
|
||||
if heights[i] > heights[st[len(st)-1]] {
|
||||
st = append(st, i)
|
||||
} else if heights[i] == heights[st[len(st)-1]] {
|
||||
st = st[:len(st)-1]
|
||||
st = append(st, i)
|
||||
} else {
|
||||
for len(st) > 0 && heights[i] < heights[st[len(st)-1]] {
|
||||
mid := st[len(st)-1]
|
||||
st = st[:len(st)-1]
|
||||
if len(st) > 0 {
|
||||
left := st[len(st)-1]
|
||||
right := i
|
||||
w := right - left - 1
|
||||
h := heights[mid]
|
||||
result = max(result, w * h)
|
||||
}
|
||||
}
|
||||
st = append(st, i)
|
||||
}
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
func max(x, y int) int {
|
||||
if x > y {
|
||||
return x
|
||||
}
|
||||
return y
|
||||
}
|
||||
```
|
||||
|
||||
单调栈精简
|
||||
|
||||
```go
|
||||
func largestRectangleArea(heights []int) int {
|
||||
|
||||
@ -40,7 +40,7 @@
|
||||
本题依然是前序遍历和后序遍历都可以，前序求的是深度，后序求的是高度。
|
||||
|
||||
* 二叉树节点的深度：指从根节点到该节点的最长简单路径边的条数或者节点数（取决于深度从0开始还是从1开始）
|
||||
* 二叉树节点的高度：指从该节点到叶子节点的最长简单路径边的条数后者节点数（取决于高度从0开始还是从1开始）
|
||||
* 二叉树节点的高度：指从该节点到叶子节点的最长简单路径边的条数或者节点数（取决于高度从0开始还是从1开始）
|
||||
|
||||
那么使用后序遍历，其实求的是根节点到叶子节点的最小距离，就是求高度的过程，不过这个最小距离 也同样是最小深度。
|
||||
|
||||
|
||||
@ -38,7 +38,7 @@ public:
|
||||
cur = head;
|
||||
int i = 1;
|
||||
int j = vec.size() - 1; // i j为之前前后的双指针
|
||||
int count = 0; // 计数，偶数去后面，奇数取前面
|
||||
int count = 0; // 计数，偶数取后面，奇数取前面
|
||||
while (i <= j) {
|
||||
if (count % 2 == 0) {
|
||||
cur->next = vec[j];
|
||||
@ -73,7 +73,7 @@ public:
|
||||
}
|
||||
|
||||
cur = head;
|
||||
int count = 0; // 计数，偶数去后面，奇数取前面
|
||||
int count = 0; // 计数，偶数取后面，奇数取前面
|
||||
ListNode* node;
|
||||
while(que.size()) {
|
||||
if (count % 2 == 0) {
|
||||
@ -338,8 +338,85 @@ class Solution:
|
||||
return pre
|
||||
```
|
||||
### Go
|
||||
|
||||
```go
|
||||
# 方法三 分割链表
|
||||
// 方法一 数组模拟
|
||||
/**
|
||||
* Definition for singly-linked list.
|
||||
* type ListNode struct {
|
||||
* Val int
|
||||
* Next *ListNode
|
||||
* }
|
||||
*/
|
||||
func reorderList(head *ListNode) {
|
||||
vec := make([]*ListNode, 0)
|
||||
cur := head
|
||||
if cur == nil {
|
||||
return
|
||||
}
|
||||
for cur != nil {
|
||||
vec = append(vec, cur)
|
||||
cur = cur.Next
|
||||
}
|
||||
cur = head
|
||||
i := 1
|
||||
j := len(vec) - 1 // i j为前后的双指针
|
||||
count := 0 // 计数，偶数取后面，奇数取前面
|
||||
for i <= j {
|
||||
if count % 2 == 0 {
|
||||
cur.Next = vec[j]
|
||||
j--
|
||||
} else {
|
||||
cur.Next = vec[i]
|
||||
i++
|
||||
}
|
||||
cur = cur.Next
|
||||
count++
|
||||
}
|
||||
cur.Next = nil // 注意结尾
|
||||
}
|
||||
```
|
||||
|
||||
```go
|
||||
// 方法二 双向队列模拟
|
||||
/**
|
||||
* Definition for singly-linked list.
|
||||
* type ListNode struct {
|
||||
* Val int
|
||||
* Next *ListNode
|
||||
* }
|
||||
*/
|
||||
func reorderList(head *ListNode) {
|
||||
que := make([]*ListNode, 0)
|
||||
cur := head
|
||||
if cur == nil {
|
||||
return
|
||||
}
|
||||
|
||||
for cur.Next != nil {
|
||||
que = append(que, cur.Next)
|
||||
cur = cur.Next
|
||||
}
|
||||
|
||||
cur = head
|
||||
count := 0 // 计数，偶数取后面，奇数取前面
|
||||
for len(que) > 0 {
|
||||
if count % 2 == 0 {
|
||||
cur.Next = que[len(que)-1]
|
||||
que = que[:len(que)-1]
|
||||
} else {
|
||||
cur.Next = que[0]
|
||||
que = que[1:]
|
||||
}
|
||||
count++
|
||||
cur = cur.Next
|
||||
}
|
||||
cur.Next = nil // 注意结尾
|
||||
}
|
||||
```
|
||||
|
||||
```go
|
||||
// 方法三 分割链表
|
||||
func reorderList(head *ListNode) {
|
||||
var slow=head
|
||||
var fast=head
|
||||
|
||||
@ -188,34 +188,21 @@ class Solution(object):
|
||||
return stack.pop()
|
||||
```
|
||||
|
||||
另一种可行，但因为使用eval相对较慢的方法:
|
||||
另一种可行，但因为使用eval()相对较慢的方法:
|
||||
```python
|
||||
from operator import add, sub, mul
|
||||
|
||||
def div(x, y):
|
||||
# 使用整数除法的向零取整方式
|
||||
return int(x / y) if x * y > 0 else -(abs(x) // abs(y))
|
||||
|
||||
class Solution(object):
|
||||
op_map = {'+': add, '-': sub, '*': mul, '/': div}
|
||||
|
||||
def evalRPN(self, tokens):
|
||||
"""
|
||||
:type tokens: List[str]
|
||||
:rtype: int
|
||||
"""
|
||||
def evalRPN(self, tokens: List[str]) -> int:
|
||||
stack = []
|
||||
for token in tokens:
|
||||
if token in self.op_map:
|
||||
op1 = stack.pop()
|
||||
op2 = stack.pop()
|
||||
operation = self.op_map[token]
|
||||
stack.append(operation(op2, op1))
|
||||
# 判断是否为数字，因为isdigit()不识别负数，故需要排除第一位的符号
|
||||
if token.isdigit() or (len(token)>1 and token[1].isdigit()):
|
||||
stack.append(token)
|
||||
else:
|
||||
stack.append(int(token))
|
||||
return stack.pop()
|
||||
|
||||
|
||||
op2 = stack.pop()
|
||||
op1 = stack.pop()
|
||||
# 由题意"The division always truncates toward zero"，所以使用int()可以天然取整
|
||||
stack.append(str(int(eval(op1 + token + op2))))
|
||||
return int(stack.pop())
|
||||
```
|
||||
|
||||
### Go:
|
||||
|
||||
@ -337,6 +337,37 @@ public ListNode removeElements(ListNode head, int val) {
|
||||
|
||||
```
|
||||
|
||||
递归
|
||||
|
||||
```java
|
||||
/**
|
||||
* 时间复杂度 O(n)
|
||||
* 空间复杂度 O(n)
|
||||
* @param head
|
||||
* @param val
|
||||
* @return
|
||||
*/
|
||||
class Solution {
|
||||
public ListNode removeElements(ListNode head, int val) {
|
||||
if (head == null) {
|
||||
return head;
|
||||
}
|
||||
|
||||
// 假设 removeElements() 返回后面完整的已经去掉val节点的子链表
|
||||
// 在当前递归层用当前节点接住后面的子链表
|
||||
// 随后判断当前层的node是否需要被删除，如果是，就返回
|
||||
// 也可以先判断是否需要删除当前node，但是这样条件语句会比较不好想
|
||||
head.next = removeElements(head.next, val);
|
||||
if (head.val == val) {
|
||||
return head.next;
|
||||
}
|
||||
return head;
|
||||
|
||||
// 实际上就是还原一个从尾部开始重新构建链表的过程
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### Python：
|
||||
|
||||
```python
|
||||
|
||||
@ -45,7 +45,7 @@
|
||||
|
||||
那么二叉树如何可以自底向上查找呢？
|
||||
|
||||
回溯啊，二叉树回溯的过程就是从低到上。
|
||||
回溯啊，二叉树回溯的过程就是从底到上。
|
||||
|
||||
后序遍历（左右中）就是天然的回溯过程，可以根据左右子树的返回值，来处理中节点的逻辑。
|
||||
|
||||
|
||||
@ -172,7 +172,7 @@ if (result.size() == ticketNum + 1) {
|
||||
|
||||
回溯的过程中，如何遍历一个机场所对应的所有机场呢？
|
||||
|
||||
这里刚刚说过，在选择映射函数的时候，不能选择`unordered_map<string, multiset<string>> targets`， 因为一旦有元素增删multiset的迭代器就会失效，当然可能有牛逼的容器删除元素迭代器不会失效，这里就不在讨论了。
|
||||
这里刚刚说过，在选择映射函数的时候，不能选择`unordered_map<string, multiset<string>> targets`， 因为一旦有元素增删multiset的迭代器就会失效，当然可能有牛逼的容器删除元素迭代器不会失效，这里就不再讨论了。
|
||||
|
||||
**可以说本题既要找到一个对数据进行排序的容器，而且还要容易增删元素，迭代器还不能失效**。
|
||||
|
||||
|
||||
@ -72,7 +72,7 @@
|
||||
|
||||
#### 情况一：上下坡中有平坡
|
||||
|
||||
例如 [1,2,2,2,1]这样的数组，如图：
|
||||
例如 [1,2,2,2,2,1]这样的数组，如图：
|
||||
|
||||
|
||||
|
||||
|
||||
@ -801,6 +801,40 @@ impl Solution {
|
||||
}
|
||||
```
|
||||
|
||||
### Ruby
|
||||
> 递归法：
|
||||
```ruby
|
||||
# @param {TreeNode} root
|
||||
# @param {Integer} key
|
||||
# @return {TreeNode}
|
||||
def delete_node(root, key)
|
||||
return nil if root.nil?
|
||||
|
||||
right = root.right
|
||||
left = root.left
|
||||
|
||||
if root.val == key
|
||||
return right if left.nil?
|
||||
return left if right.nil?
|
||||
|
||||
node = right
|
||||
while node.left
|
||||
node = node.left
|
||||
end
|
||||
node.left = left
|
||||
|
||||
return right
|
||||
end
|
||||
|
||||
if root.val > key
|
||||
root.left = delete_node(left, key)
|
||||
else
|
||||
root.right = delete_node(right, key)
|
||||
end
|
||||
|
||||
return root
|
||||
end
|
||||
```
|
||||
|
||||
<p align="center">
|
||||
<a href="https://programmercarl.com/other/kstar.html" target="_blank">
|
||||
|
||||
@ -151,13 +151,13 @@ if (abs(target) > sum) return 0; // 此时没有方案
|
||||
|
||||
本题则是装满有几种方法。其实这就是一个组合问题了。
|
||||
|
||||
1. 确定dp数组以及下标的含义
|
||||
#### 1. 确定dp数组以及下标的含义
|
||||
|
||||
先用 二维 dp数组求解本题，dp[i][j]：使用 下标为[0, i]的nums[i]能够凑满j（包括j）这么大容量的包，有dp[i][j]种方法。
|
||||
|
||||
01背包为什么这么定义dp数组，我在[0-1背包理论基础](https://www.programmercarl.com/%E8%83%8C%E5%8C%85%E7%90%86%E8%AE%BA%E5%9F%BA%E7%A1%8001%E8%83%8C%E5%8C%85-1.html)中 确定dp数组的含义里讲解过。
|
||||
|
||||
2. 确定递推公式
|
||||
#### 2. 确定递推公式
|
||||
|
||||
我们先手动推导一下，这个二维数组里面的数值。
|
||||
|
||||
@ -264,7 +264,7 @@ if (nums[i] > j) dp[i][j] = dp[i - 1][j];
|
||||
else dp[i][j] = dp[i - 1][j] + dp[i - 1][j - nums[i]];
|
||||
```
|
||||
|
||||
3. dp数组如何初始化
|
||||
#### 3. dp数组如何初始化
|
||||
|
||||
先明确递推的方向，如图，求解 dp[2][2] 是由 上方和左上方推出。
|
||||
|
||||
@ -315,7 +315,7 @@ for (int i = 0; i < nums.size(); i++) {
|
||||
}
|
||||
```
|
||||
|
||||
4. 确定遍历顺序
|
||||
#### 4. 确定遍历顺序
|
||||
|
||||
在明确递推方向时，我们知道 当前值 是由上方和左上方推出。
|
||||
|
||||
@ -360,7 +360,7 @@ for (int j = 0; j <= bagSize; j++) { // 列，遍历背包
|
||||
这里大家可以看出，无论是以上哪种遍历，都不影响 dp[2][2]的求值，用来 推导 dp[2][2] 的数值都在。
|
||||
|
||||
|
||||
5. 举例推导dp数组
|
||||
#### 5. 举例推导dp数组
|
||||
|
||||
输入：nums: [1, 1, 1, 1, 1], target: 3
|
||||
|
||||
@ -421,7 +421,7 @@ public:
|
||||
|
||||
dp[i][j] 去掉 行的维度，即 dp[j]，表示：填满j（包括j）这么大容积的包，有dp[j]种方法。
|
||||
|
||||
2. 确定递推公式
|
||||
#### 2. 确定递推公式
|
||||
|
||||
二维DP数组递推公式： `dp[i][j] = dp[i - 1][j] + dp[i - 1][j - nums[i]];`
|
||||
|
||||
@ -429,17 +429,17 @@ dp[i][j] 去掉 行的维度，即 dp[j]，表示：填满j（包括j）这么
|
||||
|
||||
**这个公式在后面在讲解背包解决排列组合问题的时候还会用到！**
|
||||
|
||||
3. dp数组如何初始化
|
||||
#### 3. dp数组如何初始化
|
||||
|
||||
在上面 二维dp数组中，我们讲解过 dp[0][0] 初始为1，这里dp[0] 同样初始为1 ,即装满背包为0的方法有一种，放0件物品。
|
||||
|
||||
4. 确定遍历顺序
|
||||
#### 4. 确定遍历顺序
|
||||
|
||||
在[动态规划：关于01背包问题，你该了解这些！（滚动数组）](https://programmercarl.com/背包理论基础01背包-2.html)中，我们系统讲过对于01背包问题一维dp的遍历。
|
||||
|
||||
遍历物品放在外循环，遍历背包在内循环，且内循环倒序（为了保证物品只使用一次）。
|
||||
|
||||
5. 举例推导dp数组
|
||||
#### 5. 举例推导dp数组
|
||||
|
||||
输入：nums: [1, 1, 1, 1, 1], target: 3
|
||||
|
||||
@ -526,7 +526,6 @@ dp[j] += dp[j - nums[i]];
|
||||
|
||||
## 其他语言版本
|
||||
|
||||
|
||||
### Java
|
||||
```java
|
||||
class Solution {
|
||||
@ -706,6 +705,31 @@ class Solution:
|
||||
```
|
||||
|
||||
### Go
|
||||
回溯法思路
|
||||
```go
|
||||
func findTargetSumWays(nums []int, target int) int {
|
||||
var result int
|
||||
var backtracking func(nums []int, target int, index int, currentSum int)
|
||||
|
||||
backtracking = func(nums []int, target int, index int, currentSum int) {
|
||||
if index == len(nums) {
|
||||
if currentSum == target {
|
||||
result++
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// 选择加上当前数字
|
||||
backtracking(nums, target, index+1, currentSum+nums[index])
|
||||
|
||||
// 选择减去当前数字
|
||||
backtracking(nums, target, index+1, currentSum-nums[index])
|
||||
}
|
||||
|
||||
backtracking(nums, target, 0, 0)
|
||||
return result
|
||||
}
|
||||
```
|
||||
二维dp
|
||||
```go
|
||||
func findTargetSumWays(nums []int, target int) int {
|
||||
|
||||
@ -195,6 +195,62 @@ public:
|
||||
建议大家把情况一二三想清楚了，先写出版本一的代码，然后在其基础上在做精简！
|
||||
|
||||
## 其他语言版本
|
||||
|
||||
### C
|
||||
|
||||
``` C
|
||||
/* 先用单调栈的方法计算出结果，再根据nums1中的元素去查找对应的结果 */
|
||||
/**
|
||||
* Note: The returned array must be malloced, assume caller calls free().
|
||||
*/
|
||||
int* nextGreaterElement(int* nums1, int nums1Size, int* nums2, int nums2Size, int* returnSize) {
|
||||
|
||||
/* stcak */
|
||||
int top = -1;
|
||||
int stack_len = nums2Size;
|
||||
int stack[stack_len];
|
||||
//memset(stack, 0x00, sizeof(stack));
|
||||
|
||||
/* nums2 result */
|
||||
int* result_nums2 = (int *)malloc(sizeof(int) * nums2Size);
|
||||
//memset(result_nums2, 0x00, sizeof(int) * nums2Size);
|
||||
|
||||
/* result */
|
||||
int* result = (int *)malloc(sizeof(int) * nums1Size);
|
||||
//memset(result, 0x00, sizeof(int) * nums1Size);
|
||||
*returnSize = nums1Size;
|
||||
|
||||
/* init */
|
||||
stack[++top] = 0; /* stack loaded with array subscripts */
|
||||
|
||||
for (int i = 0; i < nums2Size; i++) {
|
||||
result_nums2[i] = -1;
|
||||
}
|
||||
|
||||
/* get the result_nums2 */
|
||||
for (int i = 1; i < nums2Size; i++) {
|
||||
if (nums2[i] <= nums2[stack[top]]) {
|
||||
stack[++top] = i; /* push */
|
||||
} else {
|
||||
while ((top >= 0) && (nums2[i] > nums2[stack[top]])) {
|
||||
result_nums2[stack[top]] = nums2[i];
|
||||
top--; /* pop */
|
||||
}
|
||||
stack[++top] = i;
|
||||
}
|
||||
}
|
||||
|
||||
/* get the result */
|
||||
for (int i = 0; i < nums1Size; i++) {
|
||||
for (int j = 0; j < nums2Size; j++) {
|
||||
if (nums1[i] == nums2[j]) {
|
||||
result[i] = result_nums2[j];
|
||||
}
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
```
|
||||
### Java
|
||||
|
||||
```java
|
||||
|
||||
@ -4,8 +4,6 @@
|
||||
</a>
|
||||
<p align="center"><strong><a href="./qita/join.md">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们受益！</strong></p>
|
||||
|
||||
|
||||
|
||||
# 518.零钱兑换II
|
||||
|
||||
[力扣题目链接](https://leetcode.cn/problems/coin-change-ii/)
|
||||
@ -45,15 +43,19 @@
|
||||
|
||||
**[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[装满背包有多少种方法？组合与排列有讲究！| LeetCode：518.零钱兑换II](https://www.bilibili.com/video/BV1KM411k75j/)，相信结合视频再看本篇题解，更有助于大家对本题的理解**。
|
||||
|
||||
## 二维dp讲解
|
||||
|
||||
如果大家认真做完：[分割等和子集](https://www.programmercarl.com/0416.%E5%88%86%E5%89%B2%E7%AD%89%E5%92%8C%E5%AD%90%E9%9B%86.html) ， [最后一块石头的重量II](https://www.programmercarl.com/1049.%E6%9C%80%E5%90%8E%E4%B8%80%E5%9D%97%E7%9F%B3%E5%A4%B4%E7%9A%84%E9%87%8D%E9%87%8FII.html) 和 [目标和](https://www.programmercarl.com/0494.%E7%9B%AE%E6%A0%87%E5%92%8C.html)
|
||||
|
||||
应该会知道类似这种题目：给出一个总数，一些物品，问能否凑成这个总数。
|
||||
|
||||
## 思路
|
||||
这是典型的背包问题！
|
||||
|
||||
这是一道典型的背包问题，一看到钱币数量不限，就知道这是一个完全背包。
|
||||
本题求的是装满这个背包的物品组合数是多少。
|
||||
|
||||
因为每一种面额的硬币有无限个，所以这是完全背包。
|
||||
|
||||
对完全背包还不了解的同学，可以看这篇：[动态规划：关于完全背包，你该了解这些！](https://programmercarl.com/背包问题理论基础完全背包.html)
|
||||
对完全背包还不了解的同学，可以看这篇：[完全背包理论基础](https://programmercarl.com/背包问题理论基础完全背包.html)
|
||||
|
||||
但本题和纯完全背包不一样，**纯完全背包是凑成背包最大价值是多少，而本题是要求凑成总金额的物品组合个数！**
|
||||
|
||||
@ -69,44 +71,182 @@
|
||||
|
||||
如果问的是排列数，那么上面就是两种排列了。
|
||||
|
||||
**组合不强调元素之间的顺序，排列强调元素之间的顺序**。 其实这一点我们在讲解回溯算法专题的时候就讲过了哈。
|
||||
**组合不强调元素之间的顺序，排列强调元素之间的顺序**。 其实这一点我们在讲解回溯算法专题的时候就讲过。
|
||||
|
||||
那我为什么要介绍这些呢，因为这和下文讲解遍历顺序息息相关!
|
||||
|
||||
回归本题，动规五步曲来分析如下：
|
||||
本题其实与我们讲过 [494. 目标和](https://programmercarl.com/0494.目标和.html) 十分类似。
|
||||
|
||||
1. 确定dp数组以及下标的含义
|
||||
[494. 目标和](https://programmercarl.com/0494.目标和.html) 求的是装满背包有多少种方法，而本题是求装满背包有多少种组合。
|
||||
|
||||
这有啥区别？
|
||||
|
||||
**求装满背包有几种方法其实就是求组合数**。 不过 [494. 目标和](https://programmercarl.com/0494.目标和.html) 是 01背包，即每一类物品只有一个。
|
||||
|
||||
以下动规五部曲：
|
||||
|
||||
### 1、确定dp数组以及下标的含义
|
||||
|
||||
定义二维dp数值 dp[i][j]：使用 下标为[0, i]的coins[i]能够凑满j（包括j）这么大容量的包，有dp[i][j]种组合方法。
|
||||
|
||||
很多录友也会疑惑，凭什么上来就定义 dp数组，思考过程是什么样的， 这个思考过程我在 [01背包理论基础（二维数组）](https://programmercarl.com/背包理论基础01背包-1.html) 中的 “确定dp数组以及下标的含义” 有详细讲解。
|
||||
|
||||
（**强烈建议按照代码随想录的顺序学习，否则可能看不懂我的讲解**）
|
||||
|
||||
|
||||
### 2、确定递推公式
|
||||
|
||||
> **注意**： 这里的公式推导，与之前讲解过的 [494. 目标和](https://programmercarl.com/0494.目标和.html) 、[完全背包理论基础](https://programmercarl.com/背包问题理论基础完全背包.html) 有极大重复，所以我不在重复讲解原理，而是只讲解区别。
|
||||
|
||||
我们再回顾一下，[01背包理论基础](https://programmercarl.com/背包理论基础01背包-1.html)，中二维DP数组的递推公式为：
|
||||
|
||||
`dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i])`
|
||||
|
||||
在 [完全背包理论基础](https://programmercarl.com/背包问题理论基础完全背包.html) 详细讲解了完全背包二维DP数组的递推公式为：
|
||||
|
||||
`dp[i][j] = max(dp[i - 1][j], dp[i][j - weight[i]] + value[i])`
|
||||
|
||||
|
||||
看去完全背包 和 01背包的差别在哪里？
|
||||
|
||||
在于01背包是 `dp[i - 1][j - weight[i]] + value[i]` ，完全背包是 `dp[i][j - weight[i]] + value[i])`
|
||||
|
||||
主要原因就是 完全背包单类物品有无限个。
|
||||
|
||||
具体原因我在 [完全背包理论基础（二维）](https://programmercarl.com/背包问题理论基础完全背包.html) 的 「确定递推公式」有详细讲解，如果大家忘了，再回顾一下。
|
||||
|
||||
我上面有说过，本题和 [494. 目标和](https://programmercarl.com/0494.目标和.html) 是一样的，唯一区别就是 [494. 目标和](https://programmercarl.com/0494.目标和.html) 是 01背包，本题是完全背包。
|
||||
|
||||
|
||||
在[494. 目标和](https://programmercarl.com/0494.目标和.html)中详解讲解了装满背包有几种方法，二维DP数组的递推公式：
|
||||
`dp[i][j] = dp[i - 1][j] + dp[i - 1][j - nums[i]]`
|
||||
|
||||
所以本题递推公式：`dp[i][j] = dp[i - 1][j] + dp[i][j - nums[i]]` ，区别依然是 ` dp[i - 1][j - nums[i]]` 和 `dp[i][j - nums[i]]`
|
||||
|
||||
这个 ‘所以’ 我省略了很多推导的内容，因为这些内容在 [494. 目标和](https://programmercarl.com/0494.目标和.html) 和 [完全背包理论基础](https://programmercarl.com/背包问题理论基础完全背包.html) 都详细讲过。
|
||||
|
||||
这里不再重复讲解。
|
||||
|
||||
大家主要疑惑点
|
||||
|
||||
1、 `dp[i][j] = dp[i - 1][j] + dp[i][j - nums[i]]` 这个递归公式框架怎么来的，在 [494. 目标和](https://programmercarl.com/0494.目标和.html) 有详细讲解。
|
||||
|
||||
2、为什么是 ` dp[i][j - nums[i]]` 而不是 ` dp[i - 1][j - nums[i]]` ，在[完全背包理论基础（二维）](https://programmercarl.com/背包问题理论基础完全背包.html) 有详细讲解
|
||||
|
||||
|
||||
### 3. dp数组如何初始化
|
||||
|
||||
那么二维数组的最上行 和 最左列一定要初始化，这是递推公式推导的基础，如图红色部分：
|
||||
|
||||
|
||||
|
||||
|
||||
这里首先要关注的就是 dp[0][0] 应该是多少？
|
||||
|
||||
背包空间为0，装满「物品0」 的组合数有多少呢？
|
||||
|
||||
应该是 0 个， 但如果 「物品0」 的 数值就是0呢？ 岂不是可以有无限个0 组合 和为0！
|
||||
|
||||
题目描述中说了`1 <= coins.length <= 300` ，所以不用考虑 物品数值为0的情况。
|
||||
|
||||
那么最上行dp[0][j] 如何初始化呢？
|
||||
|
||||
dp[0][j]的含义：用「物品0」（即coins[0]） 装满 背包容量为j的背包，有几种组合方法。 （如果看不懂dp数组的含义，建议先学习[494. 目标和](https://programmercarl.com/0494.目标和.html)）
|
||||
|
||||
如果 j 可以整除 物品0，那么装满背包就有1种组合方法。
|
||||
|
||||
初始化代码：
|
||||
|
||||
```CPP
|
||||
for (int j = 0; j <= bagSize; j++) {
|
||||
if (j % coins[0] == 0) dp[0][j] = 1;
|
||||
}
|
||||
```
|
||||
|
||||
最左列如何初始化呢？
|
||||
|
||||
dp[i][0] 的含义：用物品i（即coins[i]） 装满容量为0的背包 有几种组合方法。
|
||||
|
||||
都有一种方法，即不装。
|
||||
|
||||
所以 dp[i][0] 都初始化为1
|
||||
|
||||
### 4. 确定遍历顺序
|
||||
|
||||
二维DP数组的完全背包的两个for循环先后顺序是无所谓的。
|
||||
|
||||
先遍历背包，还是先遍历物品都是可以的。
|
||||
|
||||
原理和 [01背包理论基础（二维数组）](https://programmercarl.com/背包理论基础01背包-1.html) 中的 「遍历顺序」是一样的，都是因为 两个for循环的先后顺序不影响 递推公式 所需要的数值。
|
||||
|
||||
具体分析过程看 [01背包理论基础（二维数组）](https://programmercarl.com/背包理论基础01背包-1.html) 中的 「遍历顺序」
|
||||
|
||||
### 5. 打印DP数组
|
||||
|
||||
以amount为5，coins为：[2,3,5] 为例：
|
||||
|
||||
dp数组应该是这样的：
|
||||
|
||||
```
|
||||
1 0 1 0 1 0
|
||||
1 0 1 1 1 1
|
||||
1 0 1 1 1 2
|
||||
```
|
||||
|
||||
### 代码实现：
|
||||
|
||||
```CPP
|
||||
class Solution {
|
||||
public:
|
||||
int change(int amount, vector<int>& coins) {
|
||||
int bagSize = amount;
|
||||
|
||||
vector<vector<uint64_t>> dp(coins.size(), vector<uint64_t>(bagSize + 1, 0));
|
||||
|
||||
// 初始化最上行
|
||||
for (int j = 0; j <= bagSize; j++) {
|
||||
if (j % coins[0] == 0) dp[0][j] = 1;
|
||||
}
|
||||
// 初始化最左列
|
||||
for (int i = 0; i < coins.size(); i++) {
|
||||
dp[i][0] = 1;
|
||||
}
|
||||
// 以下遍历顺序行列可以颠倒
|
||||
for (int i = 1; i < coins.size(); i++) { // 行，遍历物品
|
||||
for (int j = 0; j <= bagSize; j++) { // 列，遍历背包
|
||||
if (coins[i] > j) dp[i][j] = dp[i - 1][j];
|
||||
else dp[i][j] = dp[i - 1][j] + dp[i][j - coins[i]];
|
||||
}
|
||||
}
|
||||
return dp[coins.size() - 1][bagSize];
|
||||
}
|
||||
};
|
||||
```
|
||||
|
||||
## 一维dp讲解
|
||||
|
||||
### 1、确定dp数组以及下标的含义
|
||||
|
||||
dp[j]：凑成总金额j的货币组合数为dp[j]
|
||||
|
||||
2. 确定递推公式
|
||||
### 2、确定递推公式
|
||||
|
||||
dp[j] 就是所有的dp[j - coins[i]]（考虑coins[i]的情况）相加。
|
||||
本题 二维dp 递推公式： `dp[i][j] = dp[i - 1][j] + dp[i][j - coins[i]]`
|
||||
|
||||
所以递推公式：dp[j] += dp[j - coins[i]];
|
||||
压缩成一维：`dp[j] += dp[j - coins[i]]`
|
||||
|
||||
**这个递推公式大家应该不陌生了，我在讲解01背包题目的时候在这篇[494. 目标和](https://programmercarl.com/0494.目标和.html)中就讲解了，求装满背包有几种方法，公式都是：dp[j] += dp[j - nums[i]];**
|
||||
这个递推公式大家应该不陌生了，我在讲解01背包题目的时候在这篇[494. 目标和](https://programmercarl.com/0494.目标和.html)中就讲解了，求装满背包有几种方法，公式都是：`dp[j] += dp[j - nums[i]]`
|
||||
|
||||
3. dp数组如何初始化
|
||||
### 3. dp数组如何初始化
|
||||
|
||||
首先dp[0]一定要为1，dp[0] = 1是 递归公式的基础。如果dp[0] = 0 的话，后面所有推导出来的值都是0了。
|
||||
装满背包容量为0 的方法是1，即不放任何物品，`dp[0] = 1`
|
||||
|
||||
那么 dp[0] = 1 有没有含义，其实既可以说 凑成总金额0的货币组合数为1，也可以说 凑成总金额0的货币组合数为0，好像都没有毛病。
|
||||
### 4. 确定遍历顺序
|
||||
|
||||
但题目描述中，也没明确说 amount = 0 的情况，结果应该是多少。
|
||||
|
||||
这里我认为题目描述还是要说明一下，因为后台测试数据是默认，amount = 0 的情况，组合数为1的。
|
||||
|
||||
下标非0的dp[j]初始化为0，这样累计加dp[j - coins[i]]的时候才不会影响真正的dp[j]
|
||||
|
||||
dp[0]=1还说明了一种情况：如果正好选了coins[i]后，也就是j-coins[i] == 0的情况表示这个硬币刚好能选，此时dp[0]为1表示只选coins[i]存在这样的一种选法。
|
||||
|
||||
4. 确定遍历顺序
|
||||
|
||||
本题中我们是外层for循环遍历物品（钱币），内层for遍历背包（金钱总额），还是外层for遍历背包（金钱总额），内层for循环遍历物品（钱币）呢？
|
||||
|
||||
|
||||
我在[动态规划：关于完全背包，你该了解这些！](https://programmercarl.com/背包问题理论基础完全背包.html)中讲解了完全背包的两个for循环的先后顺序都是可以的。
|
||||
我在[完全背包（一维DP）](./背包问题完全背包一维.md)中讲解了完全背包的两个for循环的先后顺序都是可以的。
|
||||
|
||||
**但本题就不行了！**
|
||||
|
||||
@ -116,7 +256,7 @@ dp[0]=1还说明了一种情况：如果正好选了coins[i]后，也就是j-coi
|
||||
|
||||
所以纯完全背包是能凑成总和就行，不用管怎么凑的。
|
||||
|
||||
本题是求凑出来的方案个数，且每个方案个数是为组合数。
|
||||
本题是求凑出来的方案个数，且每个方案个数是组合数。
|
||||
|
||||
那么本题，两个for循环的先后顺序可就有说法了。
|
||||
|
||||
@ -154,7 +294,7 @@ for (int j = 0; j <= amount; j++) { // 遍历背包容量
|
||||
|
||||
可能这里很多同学还不是很理解，**建议动手把这两种方案的dp数组数值变化打印出来，对比看一看！（实践出真知）**
|
||||
|
||||
5. 举例推导dp数组
|
||||
### 5. 举例推导dp数组
|
||||
|
||||
输入: amount = 5, coins = [1, 2, 5] ，dp状态图如下：
|
||||
|
||||
@ -208,7 +348,17 @@ public:
|
||||
|
||||
## 总结
|
||||
|
||||
本题的递推公式，其实我们在[494. 目标和](https://programmercarl.com/0494.目标和.html)中就已经讲过了，**而难点在于遍历顺序！**
|
||||
本题我们从 二维 分析到 一维。
|
||||
|
||||
大家在刚开始学习的时候，从二维开始学习 容易理解。
|
||||
|
||||
之后，推荐大家直接掌握一维的写法，熟练后更容易写出来。
|
||||
|
||||
本题中，二维dp主要是就要 想清楚和我们之前讲解的 [01背包理论基础](https://programmercarl.com/背包理论基础01背包-1.html)、[494. 目标和](https://programmercarl.com/0494.目标和.html)、 [完全背包理论基础](https://programmercarl.com/背包问题理论基础完全背包.html) 联系与区别。
|
||||
|
||||
这也是代码随想录安排刷题顺序的精髓所在。
|
||||
|
||||
本题的一维dp中，难点在于理解便利顺序。
|
||||
|
||||
在求装满背包有几种方案的时候，认清遍历顺序是非常关键的。
|
||||
|
||||
@ -216,8 +366,7 @@ public:
|
||||
|
||||
**如果求排列数就是外层for遍历背包，内层for循环遍历物品**。
|
||||
|
||||
可能说到排列数录友们已经有点懵了，后面Carl还会安排求排列数的题目，到时候在对比一下，大家就会发现神奇所在！
|
||||
|
||||
可能说到排列数录友们已经有点懵了，后面我还会安排求排列数的题目，到时候在对比一下，大家就会发现神奇所在！
|
||||
|
||||
|
||||
## 其他语言版本
|
||||
@ -444,4 +593,3 @@ public class Solution
|
||||
<a href="https://programmercarl.com/other/kstar.html" target="_blank">
|
||||
<img src="../pics/网站星球宣传海报.jpg" width="1000"/>
|
||||
</a>
|
||||
|
||||
|
||||
@ -422,38 +422,38 @@ void myLinkedListFree(MyLinkedList* obj) {
|
||||
|
||||
```Java
|
||||
//单链表
|
||||
class ListNode {
|
||||
int val;
|
||||
ListNode next;
|
||||
ListNode(){}
|
||||
ListNode(int val) {
|
||||
this.val=val;
|
||||
}
|
||||
}
|
||||
class MyLinkedList {
|
||||
|
||||
class ListNode {
|
||||
int val;
|
||||
ListNode next;
|
||||
ListNode(int val) {
|
||||
this.val=val;
|
||||
}
|
||||
}
|
||||
//size存储链表元素的个数
|
||||
int size;
|
||||
//虚拟头结点
|
||||
ListNode head;
|
||||
private int size;
|
||||
//注意这里记录的是虚拟头结点
|
||||
private ListNode head;
|
||||
|
||||
//初始化链表
|
||||
public MyLinkedList() {
|
||||
size = 0;
|
||||
head = new ListNode(0);
|
||||
this.size = 0;
|
||||
this.head = new ListNode(0);
|
||||
}
|
||||
|
||||
//获取第index个节点的数值，注意index是从0开始的，第0个节点就是头结点
|
||||
//获取第index个节点的数值，注意index是从0开始的，第0个节点就是虚拟头结点
|
||||
public int get(int index) {
|
||||
//如果index非法，返回-1
|
||||
if (index < 0 || index >= size) {
|
||||
return -1;
|
||||
}
|
||||
ListNode currentNode = head;
|
||||
//包含一个虚拟头节点，所以查找第 index+1 个节点
|
||||
ListNode cur = head;
|
||||
//第0个节点是虚拟头节点，所以查找第 index+1 个节点
|
||||
for (int i = 0; i <= index; i++) {
|
||||
currentNode = currentNode.next;
|
||||
cur = cur.next;
|
||||
}
|
||||
return currentNode.val;
|
||||
return cur.val;
|
||||
}
|
||||
|
||||
public void addAtHead(int val) {
|
||||
@ -473,7 +473,6 @@ class MyLinkedList {
|
||||
while (cur.next != null) {
|
||||
cur = cur.next;
|
||||
}
|
||||
|
||||
cur.next = newNode;
|
||||
size++;
|
||||
|
||||
@ -485,55 +484,53 @@ class MyLinkedList {
|
||||
// 如果 index 等于链表的长度，则说明是新插入的节点为链表的尾结点
|
||||
// 如果 index 大于链表的长度，则返回空
|
||||
public void addAtIndex(int index, int val) {
|
||||
if (index > size) {
|
||||
if (index < 0 || index > size) {
|
||||
return;
|
||||
}
|
||||
if (index < 0) {
|
||||
index = 0;
|
||||
}
|
||||
size++;
|
||||
|
||||
//找到要插入节点的前驱
|
||||
ListNode pred = head;
|
||||
ListNode pre = head;
|
||||
for (int i = 0; i < index; i++) {
|
||||
pred = pred.next;
|
||||
pre = pre.next;
|
||||
}
|
||||
ListNode toAdd = new ListNode(val);
|
||||
toAdd.next = pred.next;
|
||||
pred.next = toAdd;
|
||||
ListNode newNode = new ListNode(val);
|
||||
newNode.next = pre.next;
|
||||
pre.next = newNode;
|
||||
size++;
|
||||
}
|
||||
|
||||
//删除第index个节点
|
||||
public void deleteAtIndex(int index) {
|
||||
if (index < 0 || index >= size) {
|
||||
return;
|
||||
}
|
||||
size--;
|
||||
//因为有虚拟头节点，所以不用对Index=0的情况进行特殊处理
|
||||
ListNode pred = head;
|
||||
|
||||
//因为有虚拟头节点，所以不用对index=0的情况进行特殊处理
|
||||
ListNode pre = head;
|
||||
for (int i = 0; i < index ; i++) {
|
||||
pred = pred.next;
|
||||
pre = pre.next;
|
||||
}
|
||||
pred.next = pred.next.next;
|
||||
pre.next = pre.next.next;
|
||||
size--;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
```Java
|
||||
//双链表
|
||||
class ListNode{
|
||||
int val;
|
||||
ListNode next,prev;
|
||||
ListNode() {};
|
||||
ListNode(int val){
|
||||
this.val = val;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
class MyLinkedList {
|
||||
|
||||
class ListNode{
|
||||
int val;
|
||||
ListNode next, prev;
|
||||
ListNode(int val){
|
||||
this.val = val;
|
||||
}
|
||||
}
|
||||
|
||||
//记录链表中元素的数量
|
||||
int size;
|
||||
private int size;
|
||||
//记录链表的虚拟头结点和尾结点
|
||||
ListNode head,tail;
|
||||
private ListNode head, tail;
|
||||
|
||||
public MyLinkedList() {
|
||||
//初始化操作
|
||||
@ -541,25 +538,25 @@ class MyLinkedList {
|
||||
this.head = new ListNode(0);
|
||||
this.tail = new ListNode(0);
|
||||
//这一步非常关键，否则在加入头结点的操作中会出现null.next的错误！！！
|
||||
head.next=tail;
|
||||
tail.prev=head;
|
||||
this.head.next = tail;
|
||||
this.tail.prev = head;
|
||||
}
|
||||
|
||||
public int get(int index) {
|
||||
//判断index是否有效
|
||||
if(index>=size){
|
||||
if(index < 0 || index >= size){
|
||||
return -1;
|
||||
}
|
||||
ListNode cur = this.head;
|
||||
ListNode cur = head;
|
||||
//判断是哪一边遍历时间更短
|
||||
if(index >= size / 2){
|
||||
//tail开始
|
||||
cur = tail;
|
||||
for(int i=0; i< size-index; i++){
|
||||
for(int i = 0; i < size - index; i++){
|
||||
cur = cur.prev;
|
||||
}
|
||||
}else{
|
||||
for(int i=0; i<= index; i++){
|
||||
for(int i = 0; i <= index; i++){
|
||||
cur = cur.next;
|
||||
}
|
||||
}
|
||||
@ -568,24 +565,23 @@ class MyLinkedList {
|
||||
|
||||
public void addAtHead(int val) {
|
||||
//等价于在第0个元素前添加
|
||||
addAtIndex(0,val);
|
||||
addAtIndex(0, val);
|
||||
}
|
||||
|
||||
public void addAtTail(int val) {
|
||||
//等价于在最后一个元素(null)前添加
|
||||
addAtIndex(size,val);
|
||||
addAtIndex(size, val);
|
||||
}
|
||||
|
||||
public void addAtIndex(int index, int val) {
|
||||
//index大于链表长度
|
||||
if(index>size){
|
||||
//判断index是否有效
|
||||
if(index < 0 || index > size){
|
||||
return;
|
||||
}
|
||||
|
||||
size++;
|
||||
//找到前驱
|
||||
ListNode pre = this.head;
|
||||
for(int i=0; i<index; i++){
|
||||
ListNode pre = head;
|
||||
for(int i = 0; i < index; i++){
|
||||
pre = pre.next;
|
||||
}
|
||||
//新建结点
|
||||
@ -594,22 +590,24 @@ class MyLinkedList {
|
||||
pre.next.prev = newNode;
|
||||
newNode.prev = pre;
|
||||
pre.next = newNode;
|
||||
size++;
|
||||
|
||||
}
|
||||
|
||||
public void deleteAtIndex(int index) {
|
||||
//判断索引是否有效
|
||||
if(index>=size){
|
||||
//判断index是否有效
|
||||
if(index < 0 || index >= size){
|
||||
return;
|
||||
}
|
||||
|
||||
//删除操作
|
||||
size--;
|
||||
ListNode pre = this.head;
|
||||
for(int i=0; i<index; i++){
|
||||
ListNode pre = head;
|
||||
for(int i = 0; i < index; i++){
|
||||
pre = pre.next;
|
||||
}
|
||||
pre.next.next.prev = pre;
|
||||
pre.next = pre.next.next;
|
||||
size--;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -190,9 +190,9 @@ class Solution:
|
||||
贪心（版本一）
|
||||
```python
|
||||
class Solution:
|
||||
def monotoneIncreasingDigits(self, N: int) -> int:
|
||||
def monotoneIncreasingDigits(self, n: int) -> int:
|
||||
# 将整数转换为字符串
|
||||
strNum = str(N)
|
||||
strNum = str(n)
|
||||
# flag用来标记赋值9从哪里开始
|
||||
# 设置为字符串长度，为了防止第二个for循环在flag没有被赋值的情况下执行
|
||||
flag = len(strNum)
|
||||
@ -216,9 +216,9 @@ class Solution:
|
||||
贪心（版本二）
|
||||
```python
|
||||
class Solution:
|
||||
def monotoneIncreasingDigits(self, N: int) -> int:
|
||||
def monotoneIncreasingDigits(self, n: int) -> int:
|
||||
# 将整数转换为字符串
|
||||
strNum = list(str(N))
|
||||
strNum = list(str(n))
|
||||
|
||||
# 从右往左遍历字符串
|
||||
for i in range(len(strNum) - 1, 0, -1):
|
||||
@ -238,9 +238,9 @@ class Solution:
|
||||
|
||||
```python
|
||||
class Solution:
|
||||
def monotoneIncreasingDigits(self, N: int) -> int:
|
||||
def monotoneIncreasingDigits(self, n: int) -> int:
|
||||
# 将整数转换为字符串
|
||||
strNum = list(str(N))
|
||||
strNum = list(str(n))
|
||||
|
||||
# 从右往左遍历字符串
|
||||
for i in range(len(strNum) - 1, 0, -1):
|
||||
@ -258,8 +258,8 @@ class Solution:
|
||||
|
||||
```python
|
||||
class Solution:
|
||||
def monotoneIncreasingDigits(self, N: int) -> int:
|
||||
strNum = str(N)
|
||||
def monotoneIncreasingDigits(self, n: int) -> int:
|
||||
strNum = str(n)
|
||||
for i in range(len(strNum) - 1, 0, -1):
|
||||
# 如果当前字符比前一个字符小，说明需要修改前一个字符
|
||||
if strNum[i - 1] > strNum[i]:
|
||||
@ -272,12 +272,12 @@ class Solution:
|
||||
```
|
||||
### Go
|
||||
```go
|
||||
func monotoneIncreasingDigits(N int) int {
|
||||
func monotoneIncreasingDigits(n int) int {
|
||||
s := strconv.Itoa(N)//将数字转为字符串，方便使用下标
|
||||
ss := []byte(s)//将字符串转为byte数组，方便更改。
|
||||
n := len(ss)
|
||||
if n <= 1 {
|
||||
return N
|
||||
return n
|
||||
}
|
||||
for i := n-1; i > 0; i-- {
|
||||
if ss[i-1] > ss[i] { //前一个大于后一位,前一位减1，后面的全部置为9
|
||||
|
||||
@ -215,6 +215,38 @@ public:
|
||||
|
||||
## 其他语言版本
|
||||
|
||||
### C：
|
||||
|
||||
```C
|
||||
/**
|
||||
* Note: The returned array must be malloced, assume caller calls free().
|
||||
*/
|
||||
int* dailyTemperatures(int* temperatures, int temperaturesSize, int* returnSize) {
|
||||
int len = temperaturesSize;
|
||||
*returnSize = len;
|
||||
|
||||
int *result = (int *)malloc(sizeof(int) * len);
|
||||
memset(result, 0x00, sizeof(int) * len);
|
||||
|
||||
int stack[len];
|
||||
memset(stack, 0x00, sizeof(stack));
|
||||
int top = 0;
|
||||
|
||||
for (int i = 1; i < len; i++) {
|
||||
if (temperatures[i] <= temperatures[stack[top]]) { /* push */
|
||||
stack[++top] = i;
|
||||
} else {
|
||||
while (top >= 0 && temperatures[i] > temperatures[stack[top]]) { /* stack not empty */
|
||||
result[stack[top]] = i - stack[top];
|
||||
top--; /* pop */
|
||||
}
|
||||
stack[++top] = i; /* push */
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
```
|
||||
|
||||
### Java：
|
||||
|
||||
```java
|
||||
|
||||
@ -11,9 +11,9 @@
|
||||
|
||||
[力扣题目链接](https://leetcode.cn/problems/sort-array-by-parity-ii/)
|
||||
|
||||
给定一个非负整数数组 A， A 中一半整数是奇数，一半整数是偶数。
|
||||
给定一个非负整数数组 nums， nums 中一半整数是奇数，一半整数是偶数。
|
||||
|
||||
对数组进行排序，以便当 A[i] 为奇数时，i 也是奇数；当 A[i] 为偶数时， i 也是偶数。
|
||||
对数组进行排序，以便当 nums[i] 为奇数时，i 也是奇数；当 nums[i] 为偶数时， i 也是偶数。
|
||||
|
||||
你可以返回任何满足上述条件的数组作为答案。
|
||||
|
||||
@ -35,17 +35,17 @@
|
||||
```CPP
|
||||
class Solution {
|
||||
public:
|
||||
vector<int> sortArrayByParityII(vector<int>& A) {
|
||||
vector<int> even(A.size() / 2); // 初始化就确定数组大小，节省开销
|
||||
vector<int> odd(A.size() / 2);
|
||||
vector<int> result(A.size());
|
||||
vector<int> sortArrayByParityII(vector<int>& nums) {
|
||||
vector<int> even(nums.size() / 2); // 初始化就确定数组大小，节省开销
|
||||
vector<int> odd(nums.size() / 2);
|
||||
vector<int> result(nums.size());
|
||||
int evenIndex = 0;
|
||||
int oddIndex = 0;
|
||||
int resultIndex = 0;
|
||||
// 把A数组放进偶数数组，和奇数数组
|
||||
for (int i = 0; i < A.size(); i++) {
|
||||
if (A[i] % 2 == 0) even[evenIndex++] = A[i];
|
||||
else odd[oddIndex++] = A[i];
|
||||
// 把nums数组放进偶数数组，和奇数数组
|
||||
for (int i = 0; i < nums.size(); i++) {
|
||||
if (nums[i] % 2 == 0) even[evenIndex++] = nums[i];
|
||||
else odd[oddIndex++] = nums[i];
|
||||
}
|
||||
// 把偶数数组，奇数数组分别放进result数组中
|
||||
for (int i = 0; i < evenIndex; i++) {
|
||||
@ -62,22 +62,22 @@ public:
|
||||
|
||||
### 方法二
|
||||
|
||||
以上代码我是建了两个辅助数组，而且A数组还相当于遍历了两次，用辅助数组的好处就是思路清晰，优化一下就是不用这两个辅助树，代码如下：
|
||||
以上代码我是建了两个辅助数组，而且nums数组还相当于遍历了两次，用辅助数组的好处就是思路清晰，优化一下就是不用这两个辅助数组，代码如下：
|
||||
|
||||
```CPP
|
||||
class Solution {
|
||||
public:
|
||||
vector<int> sortArrayByParityII(vector<int>& A) {
|
||||
vector<int> result(A.size());
|
||||
vector<int> sortArrayByParityII(vector<int>& nums) {
|
||||
vector<int> result(nums.size());
|
||||
int evenIndex = 0; // 偶数下标
|
||||
int oddIndex = 1; // 奇数下标
|
||||
for (int i = 0; i < A.size(); i++) {
|
||||
if (A[i] % 2 == 0) {
|
||||
result[evenIndex] = A[i];
|
||||
for (int i = 0; i < nums.size(); i++) {
|
||||
if (nums[i] % 2 == 0) {
|
||||
result[evenIndex] = nums[i];
|
||||
evenIndex += 2;
|
||||
}
|
||||
else {
|
||||
result[oddIndex] = A[i];
|
||||
result[oddIndex] = nums[i];
|
||||
oddIndex += 2;
|
||||
}
|
||||
}
|
||||
@ -96,15 +96,15 @@ public:
|
||||
```CPP
|
||||
class Solution {
|
||||
public:
|
||||
vector<int> sortArrayByParityII(vector<int>& A) {
|
||||
vector<int> sortArrayByParityII(vector<int>& nums) {
|
||||
int oddIndex = 1;
|
||||
for (int i = 0; i < A.size(); i += 2) {
|
||||
if (A[i] % 2 == 1) { // 在偶数位遇到了奇数
|
||||
while(A[oddIndex] % 2 != 0) oddIndex += 2; // 在奇数位找一个偶数
|
||||
swap(A[i], A[oddIndex]); // 替换
|
||||
for (int i = 0; i < nums.size(); i += 2) {
|
||||
if (nums[i] % 2 == 1) { // 在偶数位遇到了奇数
|
||||
while(nums[oddIndex] % 2 != 0) oddIndex += 2; // 在奇数位找一个偶数
|
||||
swap(nums[i], nums[oddIndex]); // 替换
|
||||
}
|
||||
}
|
||||
return A;
|
||||
return nums;
|
||||
}
|
||||
};
|
||||
```
|
||||
@ -253,6 +253,37 @@ func sortArrayByParityII(nums []int) []int {
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
// 方法二
|
||||
func sortArrayByParityII(nums []int) []int {
|
||||
result := make([]int, len(nums))
|
||||
evenIndex := 0 // 偶数下标
|
||||
oddIndex := 1 // 奇数下标
|
||||
for _, v := range nums {
|
||||
if v % 2 == 0 {
|
||||
result[evenIndex] = v
|
||||
evenIndex += 2
|
||||
} else {
|
||||
result[oddIndex] = v
|
||||
oddIndex += 2
|
||||
}
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
// 方法三
|
||||
func sortArrayByParityII(nums []int) []int {
|
||||
oddIndex := 1
|
||||
for i := 0; i < len(nums); i += 2 {
|
||||
if nums[i] % 2 == 1 { // 在偶数位遇到了奇数
|
||||
for nums[oddIndex] % 2 != 0 {
|
||||
oddIndex += 2 // 在奇数位找一个偶数
|
||||
}
|
||||
nums[i], nums[oddIndex] = nums[oddIndex], nums[i]
|
||||
}
|
||||
}
|
||||
return nums
|
||||
}
|
||||
```
|
||||
|
||||
### JavaScript
|
||||
|
||||
@ -42,40 +42,41 @@
|
||||
|
||||
## 思路
|
||||
|
||||
如果对背包问题不都熟悉先看这两篇：
|
||||
如果对背包问题不熟悉的话先看这两篇：
|
||||
|
||||
* [动态规划：关于01背包问题，你该了解这些！](https://programmercarl.com/背包理论基础01背包-1.html)
|
||||
* [动态规划：关于01背包问题，你该了解这些！（滚动数组）](https://programmercarl.com/背包理论基础01背包-2.html)
|
||||
* [01背包理论基础（二维数组）](https://programmercarl.com/背包理论基础01背包-1.html)
|
||||
* [01背包理论基础（一维数组）](https://programmercarl.com/背包理论基础01背包-2.html)
|
||||
|
||||
本题其实就是尽量让石头分成重量相同的两堆，相撞之后剩下的石头最小，**这样就化解成01背包问题了**。
|
||||
本题其实是尽量让石头分成重量相同的两堆（尽可能相同），相撞之后剩下的石头就是最小的。
|
||||
|
||||
是不是感觉和昨天讲解的[416. 分割等和子集](https://programmercarl.com/0416.分割等和子集.html)非常像了。
|
||||
一堆的石头重量是sum，那么我们就尽可能拼成 重量为 sum / 2 的石头堆。 这样剩下的石头堆也是 尽可能接近 sum/2 的重量。
|
||||
那么此时问题就是有一堆石头，每个石头都有自己的重量，是否可以 装满 最大重量为 sum / 2的背包。
|
||||
|
||||
本题物品的重量为stones[i]，物品的价值也为stones[i]。
|
||||
看到这里，大家是否感觉和昨天讲解的 [416. 分割等和子集](https://programmercarl.com/0416.分割等和子集.html)非常像了，简直就是同一道题。
|
||||
|
||||
对应着01背包里的物品重量weight[i]和 物品价值value[i]。
|
||||
本题**这样就化解成01背包问题了**。
|
||||
|
||||
**[416. 分割等和子集](https://programmercarl.com/0416.分割等和子集.html) 是求背包是否正好装满，而本题是求背包最多能装多少**。
|
||||
|
||||
物品就是石头，物品的重量为stones[i]，物品的价值也为stones[i]。
|
||||
|
||||
接下来进行动规五步曲：
|
||||
|
||||
1. 确定dp数组以及下标的含义
|
||||
### 1. 确定dp数组以及下标的含义
|
||||
|
||||
**dp[j]表示容量（这里说容量更形象，其实就是重量）为j的背包，最多可以背最大重量为dp[j]**。
|
||||
|
||||
可以回忆一下01背包中，dp[j]的含义，容量为j的背包，最多可以装的价值为 dp[j]。
|
||||
相对于 01背包，本题中，石头的重量是 stones[i]，石头的价值也是 stones[i] 。
|
||||
|
||||
相对于 01背包，本题中，石头的重量是 stones[i]，石头的价值也是 stones[i] ，可以 “最多可以装的价值为 dp[j]” == “最多可以背的重量为dp[j]”
|
||||
“最多可以装的价值为 dp[j]” 等同于 “最多可以背的重量为dp[j]”
|
||||
|
||||
2. 确定递推公式
|
||||
### 2. 确定递推公式
|
||||
|
||||
01背包的递推公式为：dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
|
||||
|
||||
本题则是：**dp[j] = max(dp[j], dp[j - stones[i]] + stones[i]);**
|
||||
|
||||
一些同学可能看到这dp[j - stones[i]] + stones[i]中 又有- stones[i] 又有+stones[i]，看着有点晕乎。
|
||||
|
||||
大家可以再去看 dp[j]的含义。
|
||||
|
||||
3. dp数组如何初始化
|
||||
### 3. dp数组如何初始化
|
||||
|
||||
既然 dp[j]中的j表示容量，那么最大容量（重量）是多少呢，就是所有石头的重量和。
|
||||
|
||||
@ -95,7 +96,7 @@
|
||||
vector<int> dp(15001, 0);
|
||||
```
|
||||
|
||||
4. 确定遍历顺序
|
||||
### 4. 确定遍历顺序
|
||||
|
||||
|
||||
在[动态规划：关于01背包问题，你该了解这些！（滚动数组）](https://programmercarl.com/背包理论基础01背包-2.html)中就已经说明：如果使用一维dp数组，物品遍历的for循环放在外层，遍历背包的for循环放在内层，且内层for循环倒序遍历！
|
||||
@ -111,7 +112,7 @@ for (int i = 0; i < stones.size(); i++) { // 遍历物品
|
||||
|
||||
```
|
||||
|
||||
5. 举例推导dp数组
|
||||
### 5. 举例推导dp数组
|
||||
|
||||
举例，输入：[2,4,1,1]，此时target = (2 + 4 + 1 + 1)/2 = 4 ，dp数组状态图如下：
|
||||
|
||||
@ -154,10 +155,7 @@ public:
|
||||
|
||||
本题其实和[416. 分割等和子集](https://programmercarl.com/0416.分割等和子集.html)几乎是一样的，只是最后对dp[target]的处理方式不同。
|
||||
|
||||
[416. 分割等和子集](https://programmercarl.com/0416.分割等和子集.html)相当于是求背包是否正好装满，而本题是求背包最多能装多少。
|
||||
|
||||
|
||||
|
||||
**[416. 分割等和子集](https://programmercarl.com/0416.分割等和子集.html)相当于是求背包是否正好装满，而本题是求背包最多能装多少**。
|
||||
|
||||
|
||||
## 其他语言版本
|
||||
|
||||
@ -115,7 +115,7 @@ public:
|
||||
|
||||
## 其他语言版本
|
||||
|
||||
### Java：
|
||||
### Java：
|
||||
|
||||
```Java
|
||||
public int[] smallerNumbersThanCurrent(int[] nums) {
|
||||
@ -138,18 +138,51 @@ public int[] smallerNumbersThanCurrent(int[] nums) {
|
||||
|
||||
### Python：
|
||||
|
||||
```python
|
||||
> 暴力法：
|
||||
|
||||
```python3
|
||||
class Solution:
|
||||
def smallerNumbersThanCurrent(self, nums: List[int]) -> List[int]:
|
||||
res = [0 for _ in range(len(nums))]
|
||||
for i in range(len(nums)):
|
||||
cnt = 0
|
||||
for j in range(len(nums)):
|
||||
if j == i:
|
||||
continue
|
||||
if nums[i] > nums[j]:
|
||||
cnt += 1
|
||||
res[i] = cnt
|
||||
return res
|
||||
```
|
||||
|
||||
> 排序+hash：
|
||||
|
||||
```python3
|
||||
class Solution:
|
||||
# 方法一：使用字典
|
||||
def smallerNumbersThanCurrent(self, nums: List[int]) -> List[int]:
|
||||
res = nums[:]
|
||||
hash = dict()
|
||||
hash_dict = dict()
|
||||
res.sort() # 从小到大排序之后，元素下标就是小于当前数字的数字
|
||||
for i, num in enumerate(res):
|
||||
if num not in hash.keys(): # 遇到了相同的数字，那么不需要更新该 number 的情况
|
||||
hash[num] = i
|
||||
if num not in hash_dict.keys(): # 遇到了相同的数字，那么不需要更新该 number 的情况
|
||||
hash_dict[num] = i
|
||||
for i, num in enumerate(nums):
|
||||
res[i] = hash[num]
|
||||
res[i] = hash_dict[num]
|
||||
return res
|
||||
|
||||
# 方法二：使用数组
|
||||
def smallerNumbersThanCurrent(self, nums: List[int]) -> List[int]:
|
||||
# 同步进行排序和创建新数组的操作，这样可以减少一次冗余的数组复制操作，以减少一次O(n) 的复制时间开销
|
||||
sort_nums = sorted(nums)
|
||||
# 题意中 0 <= nums[i] <= 100，故range的参数设为101
|
||||
hash_lst = [0 for _ in range(101)]
|
||||
# 从后向前遍历，这样hash里存放的就是相同元素最左面的数值和下标了
|
||||
for i in range(len(sort_nums)-1,-1,-1):
|
||||
hash_lst[sort_nums[i]] = i
|
||||
for i in range(len(nums)):
|
||||
nums[i] = hash_lst[nums[i]]
|
||||
return nums
|
||||
```
|
||||
|
||||
### Go：
|
||||
@ -220,7 +253,7 @@ var smallerNumbersThanCurrent = function(nums) {
|
||||
};
|
||||
```
|
||||
|
||||
### TypeScript:
|
||||
### TypeScript：
|
||||
|
||||
> 暴力法：
|
||||
|
||||
@ -241,7 +274,7 @@ function smallerNumbersThanCurrent(nums: number[]): number[] {
|
||||
};
|
||||
```
|
||||
|
||||
> 排序+hash
|
||||
> 排序+hash：
|
||||
|
||||
```typescript
|
||||
function smallerNumbersThanCurrent(nums: number[]): number[] {
|
||||
@ -260,7 +293,7 @@ function smallerNumbersThanCurrent(nums: number[]): number[] {
|
||||
};
|
||||
```
|
||||
|
||||
### rust
|
||||
### Rust：
|
||||
```rust
|
||||
use std::collections::HashMap;
|
||||
impl Solution {
|
||||
|
||||
@ -388,6 +388,62 @@ if __name__ == "__main__":
|
||||
main()
|
||||
|
||||
```
|
||||
|
||||
### JavaScript
|
||||
|
||||
前缀和
|
||||
```js
|
||||
function func() {
|
||||
const readline = require('readline')
|
||||
const rl = readline.createInterface({
|
||||
input: process.stdin,
|
||||
output: process.stdout
|
||||
})
|
||||
let inputLines = []
|
||||
rl.on('line', function (line) {
|
||||
inputLines.push(line.trim())
|
||||
})
|
||||
|
||||
rl.on('close', function () {
|
||||
let [n, m] = inputLines[0].split(" ").map(Number)
|
||||
let c = new Array(n).fill(0)
|
||||
let r = new Array(m).fill(0)
|
||||
let arr = new Array(n)
|
||||
let sum = 0//数组总和
|
||||
let min = Infinity//设置最小值的初始值为无限大
|
||||
//定义数组
|
||||
for (let s = 0; s < n; s++) {
|
||||
arr[s] = inputLines[s + 1].split(" ").map(Number)
|
||||
}
|
||||
//每一行的和
|
||||
for (let i = 0; i < n; i++) {
|
||||
for (let j = 0; j < m; j++) {
|
||||
c[i] += arr[i][j]
|
||||
sum += arr[i][j]
|
||||
}
|
||||
}
|
||||
//每一列的和
|
||||
for (let i = 0; i < n; i++) {
|
||||
for (let j = 0; j < m; j++) {
|
||||
r[j] += arr[i][j]
|
||||
}
|
||||
}
|
||||
let sum1 = 0, sum2 = 0
|
||||
//横向切割
|
||||
for (let i = 0; i < n; i++) {
|
||||
sum1 += c[i]
|
||||
min = min < Math.abs(sum - 2 * sum1) ? min : Math.abs(sum - 2 * sum1)
|
||||
}
|
||||
//纵向切割
|
||||
for (let j = 0; j < m; j++) {
|
||||
sum2 += r[j]
|
||||
min = min < Math.abs(sum - 2 * sum2) ? min : Math.abs(sum - 2 * sum2)
|
||||
}
|
||||
console.log(min);
|
||||
})
|
||||
}
|
||||
```
|
||||
|
||||
### C
|
||||
|
||||
前缀和
|
||||
|
||||
@ -288,16 +288,6 @@ func main(){
|
||||
|
||||
|
||||
|
||||
### python：
|
||||
```Python
|
||||
class Solution:
|
||||
def change(self, s):
|
||||
lst = list(s) # Python里面的string也是不可改的，所以也是需要额外空间的。空间复杂度：O(n)。
|
||||
for i in range(len(lst)):
|
||||
if lst[i].isdigit():
|
||||
lst[i] = "number"
|
||||
return ''.join(lst)
|
||||
```
|
||||
### JavaScript:
|
||||
```js
|
||||
const readline = require("readline");
|
||||
|
||||
@ -333,6 +333,8 @@ public class Main {
|
||||
|
||||
### Python
|
||||
|
||||
Bellman-Ford方法求解含有负回路的最短路问题
|
||||
|
||||
```python
|
||||
import sys
|
||||
|
||||
@ -388,6 +390,52 @@ if __name__ == "__main__":
|
||||
|
||||
```
|
||||
|
||||
SPFA方法求解含有负回路的最短路问题
|
||||
|
||||
```python
|
||||
from collections import deque
|
||||
from math import inf
|
||||
|
||||
def main():
|
||||
n, m = [int(i) for i in input().split()]
|
||||
graph = [[] for _ in range(n+1)]
|
||||
min_dist = [inf for _ in range(n+1)]
|
||||
count = [0 for _ in range(n+1)] # 记录节点加入队列的次数
|
||||
for _ in range(m):
|
||||
s, t, v = [int(i) for i in input().split()]
|
||||
graph[s].append([t, v])
|
||||
|
||||
min_dist[1] = 0 # 初始化
|
||||
count[1] = 1
|
||||
d = deque([1])
|
||||
flag = False
|
||||
|
||||
while d: # 主循环
|
||||
cur_node = d.popleft()
|
||||
for next_node, val in graph[cur_node]:
|
||||
if min_dist[next_node] > min_dist[cur_node] + val:
|
||||
min_dist[next_node] = min_dist[cur_node] + val
|
||||
count[next_node] += 1
|
||||
if next_node not in d:
|
||||
d.append(next_node)
|
||||
if count[next_node] == n: # 如果某个点松弛了n次，说明有负回路
|
||||
flag = True
|
||||
if flag:
|
||||
break
|
||||
|
||||
if flag:
|
||||
print("circle")
|
||||
else:
|
||||
if min_dist[-1] == inf:
|
||||
print("unconnected")
|
||||
else:
|
||||
print(min_dist[-1])
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
```
|
||||
|
||||
### Go
|
||||
|
||||
### Rust
|
||||
|
||||
@ -702,7 +702,129 @@ public class Main {
|
||||
|
||||
```
|
||||
|
||||
```java
|
||||
class Edge {
|
||||
public int u; // 边的端点1
|
||||
public int v; // 边的端点2
|
||||
public int val; // 边的权值
|
||||
|
||||
public Edge() {
|
||||
}
|
||||
|
||||
public Edge(int u, int v) {
|
||||
this.u = u;
|
||||
this.v = v;
|
||||
this.val = 0;
|
||||
}
|
||||
|
||||
public Edge(int u, int v, int val) {
|
||||
this.u = u;
|
||||
this.v = v;
|
||||
this.val = val;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* SPFA算法（版本3）：处理含【负权回路】的有向图的最短路径问题
|
||||
* bellman_ford（版本3） 的队列优化算法版本
|
||||
* 限定起点、终点、至多途径k个节点
|
||||
*/
|
||||
public class SPFAForSSSP {
|
||||
|
||||
/**
|
||||
* SPFA算法
|
||||
*
|
||||
* @param n 节点个数[1,n]
|
||||
* @param graph 邻接表
|
||||
* @param startIdx 开始节点（源点）
|
||||
*/
|
||||
public static int[] spfa(int n, List<List<Edge>> graph, int startIdx, int k) {
|
||||
// 定义最大范围
|
||||
int maxVal = Integer.MAX_VALUE;
|
||||
// minDist[i] 源点到节点i的最短距离
|
||||
int[] minDist = new int[n + 1]; // 有效节点编号范围：[1,n]
|
||||
Arrays.fill(minDist, maxVal); // 初始化为maxVal
|
||||
minDist[startIdx] = 0; // 设置源点到源点的最短路径为0
|
||||
|
||||
// 定义queue记录每一次松弛更新的节点
|
||||
Queue<Integer> queue = new LinkedList<>();
|
||||
queue.offer(startIdx); // 初始化：源点开始（queue和minDist的更新是同步的）
|
||||
|
||||
|
||||
// SPFA算法核心：只对上一次松弛的时候更新过的节点关联的边进行松弛操作
|
||||
while (k + 1 > 0 && !queue.isEmpty()) { // 限定松弛 k+1 次
|
||||
int curSize = queue.size(); // 记录当前队列节点个数（上一次松弛更新的节点个数，用作分层统计）
|
||||
while (curSize-- > 0) { //分层控制，限定本次松弛只针对上一次松弛更新的节点，不对新增的节点做处理
|
||||
// 记录当前minDist状态，作为本次松弛的基础
|
||||
int[] minDist_copy = Arrays.copyOfRange(minDist, 0, minDist.length);
|
||||
|
||||
// 取出节点
|
||||
int cur = queue.poll();
|
||||
// 获取cur节点关联的边，进行松弛操作
|
||||
List<Edge> relateEdges = graph.get(cur);
|
||||
for (Edge edge : relateEdges) {
|
||||
int u = edge.u; // 与`cur`对照
|
||||
int v = edge.v;
|
||||
int weight = edge.val;
|
||||
if (minDist_copy[u] + weight < minDist[v]) {
|
||||
minDist[v] = minDist_copy[u] + weight; // 更新
|
||||
// 队列同步更新（此处有一个针对队列的优化:就是如果已经存在于队列的元素不需要重复添加）
|
||||
if (!queue.contains(v)) {
|
||||
queue.offer(v); // 与minDist[i]同步更新，将本次更新的节点加入队列，用做下一个松弛的参考基础
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
// 当次松弛结束，次数-1
|
||||
k--;
|
||||
}
|
||||
|
||||
// 返回minDist
|
||||
return minDist;
|
||||
}
|
||||
|
||||
public static void main(String[] args) {
|
||||
// 输入控制
|
||||
Scanner sc = new Scanner(System.in);
|
||||
System.out.println("1.输入N个节点、M条边（u v weight）");
|
||||
int n = sc.nextInt();
|
||||
int m = sc.nextInt();
|
||||
|
||||
System.out.println("2.输入M条边");
|
||||
List<List<Edge>> graph = new ArrayList<>(); // 构建邻接表
|
||||
for (int i = 0; i <= n; i++) {
|
||||
graph.add(new ArrayList<>());
|
||||
}
|
||||
while (m-- > 0) {
|
||||
int u = sc.nextInt();
|
||||
int v = sc.nextInt();
|
||||
int weight = sc.nextInt();
|
||||
graph.get(u).add(new Edge(u, v, weight));
|
||||
}
|
||||
|
||||
System.out.println("3.输入src dst k（起点、终点、至多途径k个点）");
|
||||
int src = sc.nextInt();
|
||||
int dst = sc.nextInt();
|
||||
int k = sc.nextInt();
|
||||
|
||||
// 调用算法
|
||||
int[] minDist = SPFAForSSSP.spfa(n, graph, src, k);
|
||||
// 校验起点->终点
|
||||
if (minDist[dst] == Integer.MAX_VALUE) {
|
||||
System.out.println("unreachable");
|
||||
} else {
|
||||
System.out.println("最短路径：" + minDist[n]);
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
|
||||
### Python
|
||||
|
||||
Bellman-Ford方法求解单源有限最短路
|
||||
|
||||
```python
|
||||
def main():
|
||||
# 輸入
|
||||
@ -736,6 +858,48 @@ def main():
|
||||
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
```
|
||||
|
||||
SPFA方法求解单源有限最短路
|
||||
|
||||
```python
|
||||
from collections import deque
|
||||
from math import inf
|
||||
|
||||
|
||||
def main():
|
||||
n, m = [int(i) for i in input().split()]
|
||||
graph = [[] for _ in range(n+1)]
|
||||
for _ in range(m):
|
||||
v1, v2, val = [int(i) for i in input().split()]
|
||||
graph[v1].append([v2, val])
|
||||
src, dst, k = [int(i) for i in input().split()]
|
||||
min_dist = [inf for _ in range(n+1)]
|
||||
min_dist[src] = 0 # 初始化起点的距离
|
||||
que = deque([src])
|
||||
|
||||
while k != -1 and que:
|
||||
visited = [False for _ in range(n+1)] # 用于保证每次松弛时一个节点最多加入队列一次
|
||||
que_size = len(que)
|
||||
temp_dist = min_dist.copy() # 用于记录上一次遍历的结果
|
||||
for _ in range(que_size):
|
||||
cur_node = que.popleft()
|
||||
for next_node, val in graph[cur_node]:
|
||||
if min_dist[next_node] > temp_dist[cur_node] + val:
|
||||
min_dist[next_node] = temp_dist[cur_node] + val
|
||||
if not visited[next_node]:
|
||||
que.append(next_node)
|
||||
visited[next_node] = True
|
||||
k -= 1
|
||||
|
||||
if min_dist[dst] == inf:
|
||||
print("unreachable")
|
||||
else:
|
||||
print(min_dist[dst])
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
```
|
||||
|
||||
@ -100,7 +100,8 @@ Floyd算法核心思想是动态规划。
|
||||
|
||||
这里我们用 grid数组来存图，那就把dp数组命名为 grid。
|
||||
|
||||
grid[i][j][k] = m，表示 节点i 到 节点j 以[1...k] 集合为中间节点的最短距离为m。
|
||||
grid[i][j][k] = m，表示 **节点i 到 节点j 以[1...k] 集合中的一个节点为中间节点的最短距离为m**。
|
||||
|
||||
|
||||
可能有录友会想，凭什么就这么定义呢？
|
||||
|
||||
@ -424,6 +425,71 @@ floyd算法的时间复杂度相对较高，适合 稠密图且源点较多的
|
||||
|
||||
### Java
|
||||
|
||||
- 基于三维数组的Floyd算法
|
||||
|
||||
```java
|
||||
public class FloydBase {
|
||||
|
||||
// public static int MAX_VAL = Integer.MAX_VALUE;
|
||||
public static int MAX_VAL = 10005; // 边的最大距离是10^4(不选用Integer.MAX_VALUE是为了避免相加导致数值溢出)
|
||||
|
||||
public static void main(String[] args) {
|
||||
// 输入控制
|
||||
Scanner sc = new Scanner(System.in);
|
||||
System.out.println("1.输入N M");
|
||||
int n = sc.nextInt();
|
||||
int m = sc.nextInt();
|
||||
|
||||
System.out.println("2.输入M条边");
|
||||
|
||||
// ① dp定义（grid[i][j][k] 节点i到节点j 可能经过节点K（k∈[1,n]））的最短路径
|
||||
int[][][] grid = new int[n + 1][n + 1][n + 1];
|
||||
for (int i = 1; i <= n; i++) {
|
||||
for (int j = 1; j <= n; j++) {
|
||||
for (int k = 0; k <= n; k++) {
|
||||
grid[i][j][k] = grid[j][i][k] = MAX_VAL; // 其余设置为最大值
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ② dp 推导：grid[i][j][k] = min{grid[i][k][k-1] + grid[k][j][k-1], grid[i][j][k-1]}
|
||||
while (m-- > 0) {
|
||||
int u = sc.nextInt();
|
||||
int v = sc.nextInt();
|
||||
int weight = sc.nextInt();
|
||||
grid[u][v][0] = grid[v][u][0] = weight; // 初始化（处理k=0的情况） ③ dp初始化
|
||||
}
|
||||
|
||||
// ④ dp推导：floyd 推导
|
||||
for (int k = 1; k <= n; k++) {
|
||||
for (int i = 1; i <= n; i++) {
|
||||
for (int j = 1; j <= n; j++) {
|
||||
grid[i][j][k] = Math.min(grid[i][k][k - 1] + grid[k][j][k - 1], grid[i][j][k - 1]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
System.out.println("3.输入[起点-终点]计划个数");
|
||||
int x = sc.nextInt();
|
||||
|
||||
System.out.println("4.输入每个起点src 终点dst");
|
||||
|
||||
while (x-- > 0) {
|
||||
int src = sc.nextInt();
|
||||
int dst = sc.nextInt();
|
||||
// 根据floyd推导结果输出计划路径的最小距离
|
||||
if (grid[src][dst][n] == MAX_VAL) {
|
||||
System.out.println("-1");
|
||||
} else {
|
||||
System.out.println(grid[src][dst][n]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
|
||||
### Python
|
||||
|
||||
基于三维数组的Floyd
|
||||
|
||||
@ -257,6 +257,54 @@ public class Main {
|
||||
|
||||
|
||||
### Python
|
||||
#### 深搜版
|
||||
```python
|
||||
position = [[1, 0], [0, 1], [-1, 0], [0, -1]]
|
||||
count = 0
|
||||
|
||||
def dfs(grid, x, y):
|
||||
global count
|
||||
grid[x][y] = 0
|
||||
count += 1
|
||||
for i, j in position:
|
||||
next_x = x + i
|
||||
next_y = y + j
|
||||
if next_x < 0 or next_y < 0 or next_x >= len(grid) or next_y >= len(grid[0]):
|
||||
continue
|
||||
if grid[next_x][next_y] == 1:
|
||||
dfs(grid, next_x, next_y)
|
||||
|
||||
n, m = map(int, input().split())
|
||||
|
||||
# 邻接矩阵
|
||||
grid = []
|
||||
for i in range(n):
|
||||
grid.append(list(map(int, input().split())))
|
||||
|
||||
# 清除边界上的连通分量
|
||||
for i in range(n):
|
||||
if grid[i][0] == 1:
|
||||
dfs(grid, i, 0)
|
||||
if grid[i][m - 1] == 1:
|
||||
dfs(grid, i, m - 1)
|
||||
|
||||
for j in range(m):
|
||||
if grid[0][j] == 1:
|
||||
dfs(grid, 0, j)
|
||||
if grid[n - 1][j] == 1:
|
||||
dfs(grid, n - 1, j)
|
||||
|
||||
count = 0 # 将count重置为0
|
||||
# 统计内部所有剩余的连通分量
|
||||
for i in range(n):
|
||||
for j in range(m):
|
||||
if grid[i][j] == 1:
|
||||
dfs(grid, i, j)
|
||||
|
||||
print(count)
|
||||
```
|
||||
|
||||
#### 广搜版
|
||||
```python
|
||||
from collections import deque
|
||||
|
||||
@ -293,17 +341,22 @@ def bfs(r, c):
|
||||
|
||||
|
||||
for i in range(n):
|
||||
if g[i][0] == 1: bfs(i, 0)
|
||||
if g[i][m-1] == 1: bfs(i, m-1)
|
||||
if g[i][0] == 1:
|
||||
bfs(i, 0)
|
||||
if g[i][m-1] == 1:
|
||||
bfs(i, m-1)
|
||||
|
||||
for i in range(m):
|
||||
if g[0][i] == 1: bfs(0, i)
|
||||
if g[n-1][i] == 1: bfs(n-1, i)
|
||||
if g[0][i] == 1:
|
||||
bfs(0, i)
|
||||
if g[n-1][i] == 1:
|
||||
bfs(n-1, i)
|
||||
|
||||
count = 0
|
||||
for i in range(n):
|
||||
for j in range(m):
|
||||
if g[i][j] == 1: bfs(i, j)
|
||||
if g[i][j] == 1:
|
||||
bfs(i, j)
|
||||
|
||||
print(count)
|
||||
```
|
||||
|
||||
@ -413,6 +413,81 @@ if __name__ == "__main__":
|
||||
```
|
||||
|
||||
### Go
|
||||
```go
|
||||
package main
|
||||
|
||||
import (
|
||||
"os"
|
||||
"fmt"
|
||||
"strings"
|
||||
"strconv"
|
||||
"bufio"
|
||||
)
|
||||
|
||||
var directions = [][]int{{0, -1}, {0, 1}, {-1, 0}, {1, 0}} // 四个方向的偏移量
|
||||
|
||||
func main() {
|
||||
scanner := bufio.NewScanner(os.Stdin)
|
||||
|
||||
scanner.Scan()
|
||||
lineList := strings.Fields(scanner.Text())
|
||||
N, _ := strconv.Atoi(lineList[0])
|
||||
M, _ := strconv.Atoi(lineList[1])
|
||||
|
||||
grid := make([][]int, N)
|
||||
visited := make([][]bool, N) // 用于标记是否访问过
|
||||
for i := 0; i < N; i++ {
|
||||
grid[i] = make([]int, M)
|
||||
visited[i] = make([]bool, M)
|
||||
scanner.Scan()
|
||||
lineList = strings.Fields(scanner.Text())
|
||||
|
||||
for j := 0; j < M; j++ {
|
||||
grid[i][j], _ = strconv.Atoi(lineList[j])
|
||||
}
|
||||
}
|
||||
|
||||
// 遍历每个单元格，使用DFS检查是否可达两组边界
|
||||
for i := 0; i < N; i++ {
|
||||
for j := 0; j < M; j++ {
|
||||
canReachFirst, canReachSecond := dfs(grid, visited, i, j)
|
||||
if canReachFirst && canReachSecond {
|
||||
fmt.Println(strconv.Itoa(i) + " " + strconv.Itoa(j))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func dfs(grid [][]int, visited [][]bool, startx int, starty int) (bool, bool) {
|
||||
visited[startx][starty] = true
|
||||
canReachFirst := startx == 0 || starty == 0 || startx == len(grid)-1 || starty == len(grid[0])-1
|
||||
canReachSecond := startx == len(grid)-1 || starty == len(grid[0])-1 || startx == 0 || starty == 0
|
||||
|
||||
if canReachFirst && canReachSecond {
|
||||
return true, true
|
||||
}
|
||||
|
||||
for _, direction := range directions {
|
||||
nextx := startx + direction[0]
|
||||
nexty := starty + direction[1]
|
||||
|
||||
if nextx < 0 || nextx >= len(grid) || nexty < 0 || nexty >= len(grid[0]) {
|
||||
continue
|
||||
}
|
||||
|
||||
if grid[nextx][nexty] <= grid[startx][starty] && !visited[nextx][nexty] {
|
||||
hasReachFirst, hasReachSecond := dfs(grid, visited, nextx, nexty)
|
||||
if !canReachFirst {
|
||||
canReachFirst = hasReachFirst
|
||||
}
|
||||
if !canReachSecond {
|
||||
canReachSecond = hasReachSecond
|
||||
}
|
||||
}
|
||||
}
|
||||
return canReachFirst, canReachSecond
|
||||
}
|
||||
```
|
||||
|
||||
### Rust
|
||||
|
||||
|
||||
@ -491,6 +491,54 @@ func main() {
|
||||
|
||||
### JavaScript
|
||||
|
||||
```javascript
|
||||
const rl = require('readline').createInterface({
|
||||
input:process.stdin,
|
||||
output:process.stdout
|
||||
})
|
||||
|
||||
let inputLines = []
|
||||
|
||||
rl.on('line' , (line)=>{
|
||||
inputLines.push(line)
|
||||
})
|
||||
|
||||
rl.on('close',()=>{
|
||||
let [n , edgesCount]= inputLines[0].trim().split(' ').map(Number)
|
||||
|
||||
let graph = Array.from({length:n+1} , ()=>{return[]})
|
||||
|
||||
for(let i = 1 ; i < inputLines.length ; i++ ){
|
||||
let [from , to] = inputLines[i].trim().split(' ').map(Number)
|
||||
graph[from].push(to)
|
||||
}
|
||||
|
||||
let visited = new Array(n + 1).fill(false)
|
||||
|
||||
let dfs = (graph , key , visited)=>{
|
||||
if(visited[key]){
|
||||
return
|
||||
}
|
||||
|
||||
visited[key] = true
|
||||
for(let nextKey of graph[key]){
|
||||
dfs(graph,nextKey , visited)
|
||||
}
|
||||
}
|
||||
|
||||
dfs(graph , 1 , visited)
|
||||
|
||||
for(let i = 1 ; i <= n;i++){
|
||||
if(visited[i] === false){
|
||||
console.log(-1)
|
||||
return
|
||||
}
|
||||
}
|
||||
console.log(1)
|
||||
|
||||
})
|
||||
```
|
||||
|
||||
### TypeScript
|
||||
|
||||
### PhP
|
||||
|
||||
@ -44,7 +44,7 @@
|
||||
|
||||
|
||||
|
||||
图中的 1 2，2 3，1 3 等三条边在删除后都能使原图变为一棵合法的树。但是 1 3 由于是标准输出里最后出现的那条边，所以输出结果为 1 3
|
||||
图中的 1 2，2 3，1 3 等三条边在删除后都能使原图变为一棵合法的树。但是 1 3 由于是标准输入里最后出现的那条边，所以输出结果为 1 3
|
||||
|
||||
数据范围：
|
||||
|
||||
|
||||
@ -27,11 +27,16 @@
|
||||
|
||||
**那我们就将访问的节点放入栈中，把要处理的节点也放入栈中但是要做标记。**
|
||||
|
||||
如何标记呢，**就是要处理的节点放入栈之后，紧接着放入一个空指针作为标记。** 这种方法也可以叫做标记法。
|
||||
如何标记呢？
|
||||
|
||||
* 方法一：**就是要处理的节点放入栈之后，紧接着放入一个空指针作为标记。** 这种方法可以叫做`空指针标记法`。
|
||||
|
||||
* 方法二：**加一个 `boolean` 值跟随每个节点，`false` (默认值) 表示需要为该节点和它的左右儿子安排在栈中的位次，`true` 表示该节点的位次之前已经安排过了，可以收割节点了。**
|
||||
这种方法可以叫做`boolean 标记法`，样例代码见下文`C++ 和 Python 的 boolean 标记法`。 这种方法更容易理解，在面试中更容易写出来。
|
||||
|
||||
### 迭代法中序遍历
|
||||
|
||||
中序遍历代码如下：（详细注释）
|
||||
> 中序遍历（空指针标记法）代码如下：（详细注释）
|
||||
|
||||
```CPP
|
||||
class Solution {
|
||||
@ -70,6 +75,45 @@ public:
|
||||
|
||||
可以看出我们将访问的节点直接加入到栈中，但如果是处理的节点则后面放入一个空节点， 这样只有空节点弹出的时候，才将下一个节点放进结果集。
|
||||
|
||||
> 中序遍历（boolean 标记法）：
|
||||
```c++
|
||||
class Solution {
|
||||
public:
|
||||
vector<int> inorderTraversal(TreeNode* root) {
|
||||
vector<int> result;
|
||||
stack<pair<TreeNode*, bool>> st;
|
||||
if (root != nullptr)
|
||||
st.push(make_pair(root, false)); // 多加一个参数，false 为默认值，含义见下文注释
|
||||
|
||||
while (!st.empty()) {
|
||||
auto node = st.top().first;
|
||||
auto visited = st.top().second; //多加一个 visited 参数，使“迭代统一写法”成为一件简单的事
|
||||
st.pop();
|
||||
|
||||
if (visited) { // visited 为 True，表示该节点和两个儿子位次之前已经安排过了，现在可以收割节点了
|
||||
result.push_back(node->val);
|
||||
continue;
|
||||
}
|
||||
|
||||
// visited 当前为 false, 表示初次访问本节点，此次访问的目的是“把自己和两个儿子在栈中安排好位次”。
|
||||
|
||||
// 中序遍历是'左中右'，右儿子最先入栈，最后出栈。
|
||||
if (node->right)
|
||||
st.push(make_pair(node->right, false));
|
||||
|
||||
// 把自己加回到栈中，位置居中。
|
||||
// 同时，设置 visited 为 true，表示下次再访问本节点时，允许收割。
|
||||
st.push(make_pair(node, true));
|
||||
|
||||
if (node->left)
|
||||
st.push(make_pair(node->left, false)); // 左儿子最后入栈，最先出栈
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
};
|
||||
```
|
||||
|
||||
此时我们再来看前序遍历代码。
|
||||
|
||||
### 迭代法前序遍历
|
||||
@ -105,7 +149,7 @@ public:
|
||||
|
||||
### 迭代法后序遍历
|
||||
|
||||
后续遍历代码如下： (**注意此时我们和中序遍历相比仅仅改变了两行代码的顺序**)
|
||||
> 后续遍历代码如下： (**注意此时我们和中序遍历相比仅仅改变了两行代码的顺序**)
|
||||
|
||||
```CPP
|
||||
class Solution {
|
||||
@ -136,6 +180,42 @@ public:
|
||||
};
|
||||
```
|
||||
|
||||
> 迭代法后序遍历（boolean 标记法）：
|
||||
```c++
|
||||
class Solution {
|
||||
public:
|
||||
vector<int> postorderTraversal(TreeNode* root) {
|
||||
vector<int> result;
|
||||
stack<pair<TreeNode*, bool>> st;
|
||||
if (root != nullptr)
|
||||
st.push(make_pair(root, false)); // 多加一个参数，false 为默认值，含义见下文
|
||||
|
||||
while (!st.empty()) {
|
||||
auto node = st.top().first;
|
||||
auto visited = st.top().second; //多加一个 visited 参数，使“迭代统一写法”成为一件简单的事
|
||||
st.pop();
|
||||
|
||||
if (visited) { // visited 为 True，表示该节点和两个儿子位次之前已经安排过了，现在可以收割节点了
|
||||
result.push_back(node->val);
|
||||
continue;
|
||||
}
|
||||
|
||||
// visited 当前为 false, 表示初次访问本节点，此次访问的目的是“把自己和两个儿子在栈中安排好位次”。
|
||||
// 后序遍历是'左右中'，节点自己最先入栈，最后出栈。
|
||||
// 同时，设置 visited 为 true，表示下次再访问本节点时，允许收割。
|
||||
st.push(make_pair(node, true));
|
||||
|
||||
if (node->right)
|
||||
st.push(make_pair(node->right, false)); // 右儿子位置居中
|
||||
|
||||
if (node->left)
|
||||
st.push(make_pair(node->left, false)); // 左儿子最后入栈，最先出栈
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
};
|
||||
```
|
||||
## 总结
|
||||
|
||||
此时我们写出了统一风格的迭代法，不用在纠结于前序写出来了，中序写不出来的情况了。
|
||||
@ -234,7 +314,7 @@ class Solution {
|
||||
|
||||
### Python：
|
||||
|
||||
迭代法前序遍历：
|
||||
> 迭代法前序遍历（空指针标记法）：
|
||||
```python
|
||||
class Solution:
|
||||
def preorderTraversal(self, root: TreeNode) -> List[int]:
|
||||
@ -257,7 +337,7 @@ class Solution:
|
||||
return result
|
||||
```
|
||||
|
||||
迭代法中序遍历：
|
||||
> 迭代法中序遍历（空指针标记法）：
|
||||
```python
|
||||
class Solution:
|
||||
def inorderTraversal(self, root: TreeNode) -> List[int]:
|
||||
@ -282,7 +362,7 @@ class Solution:
|
||||
return result
|
||||
```
|
||||
|
||||
迭代法后序遍历：
|
||||
> 迭代法后序遍历（空指针标记法）：
|
||||
```python
|
||||
class Solution:
|
||||
def postorderTraversal(self, root: TreeNode) -> List[int]:
|
||||
@ -306,6 +386,61 @@ class Solution:
|
||||
return result
|
||||
```
|
||||
|
||||
> 中序遍历，统一迭代（boolean 标记法）：
|
||||
```python
|
||||
class Solution:
|
||||
def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
|
||||
values = []
|
||||
stack = [(root, False)] if root else [] # 多加一个参数，False 为默认值，含义见下文
|
||||
|
||||
while stack:
|
||||
node, visited = stack.pop() # 多加一个 visited 参数，使“迭代统一写法”成为一件简单的事
|
||||
|
||||
if visited: # visited 为 True，表示该节点和两个儿子的位次之前已经安排过了，现在可以收割节点了
|
||||
values.append(node.val)
|
||||
continue
|
||||
|
||||
# visited 当前为 False, 表示初次访问本节点，此次访问的目的是“把自己和两个儿子在栈中安排好位次”。
|
||||
# 中序遍历是'左中右'，右儿子最先入栈，最后出栈。
|
||||
if node.right:
|
||||
stack.append((node.right, False))
|
||||
|
||||
stack.append((node, True)) # 把自己加回到栈中，位置居中。同时，设置 visited 为 True，表示下次再访问本节点时，允许收割
|
||||
|
||||
if node.left:
|
||||
stack.append((node.left, False)) # 左儿子最后入栈，最先出栈
|
||||
|
||||
return values
|
||||
```
|
||||
|
||||
> 后序遍历，统一迭代（boolean 标记法）：
|
||||
```python
|
||||
class Solution:
|
||||
def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
|
||||
values = []
|
||||
stack = [(root, False)] if root else [] # 多加一个参数，False 为默认值，含义见下文
|
||||
|
||||
while stack:
|
||||
node, visited = stack.pop() # 多加一个 visited 参数，使“迭代统一写法”成为一件简单的事
|
||||
|
||||
if visited: # visited 为 True，表示该节点和两个儿子位次之前已经安排过了，现在可以收割节点了
|
||||
values.append(node.val)
|
||||
continue
|
||||
|
||||
# visited 当前为 False, 表示初次访问本节点，此次访问的目的是“把自己和两个儿子在栈中安排好位次”
|
||||
# 后序遍历是'左右中'，节点自己最先入栈，最后出栈。
|
||||
# 同时，设置 visited 为 True，表示下次再访问本节点时，允许收割。
|
||||
stack.append((node, True))
|
||||
|
||||
if node.right:
|
||||
stack.append((node.right, False)) # 右儿子位置居中
|
||||
|
||||
if node.left:
|
||||
stack.append((node.left, False)) # 左儿子最后入栈，最先出栈
|
||||
|
||||
return values
|
||||
```
|
||||
|
||||
### Go：
|
||||
|
||||
> 前序遍历统一迭代法
|
||||
|
||||
@ -75,7 +75,7 @@ for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target;
|
||||
|
||||
除了这些难点，**本题还有细节，例如：切割过的地方不能重复切割所以递归函数需要传入i + 1**。
|
||||
|
||||
所以本题应该是一个道hard题目了。
|
||||
所以本题应该是一道hard题目了。
|
||||
|
||||
**本题的树形结构中，和代码的逻辑有一个小出入，已经判断不是回文的子串就不会进入递归了，纠正如下：**
|
||||
|
||||
|
||||
@ -99,7 +99,7 @@ public:
|
||||
|
||||
这道绝佳的面试题我没有用过，如果录友们有面试别人的需求，就把这个套路拿去吧。
|
||||
|
||||
我在[通过一道面试题目，讲一讲递归算法的时间复杂度！](https://programmercarl.com/前序/通过一道面试题目，讲一讲递归算法的时间复杂度！.html)中，以我自己面试别人的真实经历，通过求x的n次方 这么简单的题目，就可以考察候选人对算法性能以及递归的理解深度，录友们可以看看，绝对有收获！
|
||||
我在[通过一道面试题目，讲一讲递归算法的时间复杂度！](../前序/递归算法的时间复杂度.md)中，以我自己面试别人的真实经历，通过求x的n次方 这么简单的题目，就可以考察候选人对算法性能以及递归的理解深度，录友们可以看看，绝对有收获！
|
||||
|
||||
## 周四
|
||||
|
||||
|
||||
@ -41,8 +41,6 @@ leetcode上没有纯01背包的问题，都是01背包应用方面的题目，
|
||||
|
||||
有n件物品和一个最多能背重量为w 的背包。第i件物品的重量是weight[i]，得到的价值是value[i] 。**每件物品只能用一次**，求解将哪些物品装入背包里物品价值总和最大。
|
||||
|
||||
|
||||
|
||||
这是标准的背包问题，以至于很多同学看了这个自然就会想到背包，甚至都不知道暴力的解法应该怎么解了。
|
||||
|
||||
这样其实是没有从底向上去思考，而是习惯性想到了背包，那么暴力的解法应该是怎么样的呢？
|
||||
@ -73,7 +71,7 @@ leetcode上没有纯01背包的问题，都是01背包应用方面的题目，
|
||||
|
||||
依然动规五部曲分析一波。
|
||||
|
||||
1. 确定dp数组以及下标的含义
|
||||
#### 1. 确定dp数组以及下标的含义
|
||||
|
||||
我们需要使用二维数组，为什么呢？
|
||||
|
||||
@ -131,7 +129,7 @@ i 来表示物品、j表示背包容量。
|
||||
|
||||
**要时刻记着这个dp数组的含义，下面的一些步骤都围绕这dp数组的含义进行的**，如果哪里看懵了，就来回顾一下i代表什么，j又代表什么。
|
||||
|
||||
2. 确定递推公式
|
||||
#### 2. 确定递推公式
|
||||
|
||||
这里在把基本信息给出来：
|
||||
|
||||
@ -176,7 +174,7 @@ i 来表示物品、j表示背包容量。
|
||||
|
||||
递归公式： `dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);`
|
||||
|
||||
3. dp数组如何初始化
|
||||
#### 3. dp数组如何初始化
|
||||
|
||||
**关于初始化，一定要和dp数组的定义吻合，否则到递推公式的时候就会越来越乱**。
|
||||
|
||||
@ -197,8 +195,8 @@ dp[0][j]，即：i为0，存放编号0的物品的时候，各个容量的背包
|
||||
代码初始化如下：
|
||||
|
||||
```CPP
|
||||
for (int j = 0 ; j < weight[0]; j++) { // 当然这一步，如果把dp数组预先初始化为0了，这一步就可以省略，但很多同学应该没有想清楚这一点。
|
||||
dp[0][j] = 0;
|
||||
for (int i = 1; i < weight.size(); i++) { // 当然这一步，如果把dp数组预先初始化为0了，这一步就可以省略，但很多同学应该没有想清楚这一点。
|
||||
dp[i][0] = 0;
|
||||
}
|
||||
// 正序遍历
|
||||
for (int j = weight[0]; j <= bagweight; j++) {
|
||||
@ -236,7 +234,7 @@ for (int j = weight[0]; j <= bagweight; j++) {
|
||||
|
||||
**费了这么大的功夫，才把如何初始化讲清楚，相信不少同学平时初始化dp数组是凭感觉来的，但有时候感觉是不靠谱的**。
|
||||
|
||||
4. 确定遍历顺序
|
||||
#### 4. 确定遍历顺序
|
||||
|
||||
在如下图中，可以看出，有两个遍历的维度：物品与背包重量
|
||||
|
||||
@ -293,7 +291,7 @@ dp[i-1][j]和dp[i - 1][j - weight[i]] 都在dp[i][j]的左上角方向（包括
|
||||
|
||||
**其实背包问题里，两个for循环的先后循序是非常有讲究的，理解遍历顺序其实比理解推导公式难多了**。
|
||||
|
||||
5. 举例推导dp数组
|
||||
#### 5. 举例推导dp数组
|
||||
|
||||
来看一下对应的dp数组的数值，如图：
|
||||
|
||||
|
||||
211
problems/背包问题完全背包一维.md
Normal file
211
problems/背包问题完全背包一维.md
Normal file
@ -0,0 +1,211 @@
|
||||
|
||||
# 完全背包-一维数组
|
||||
|
||||
本题力扣上没有原题，大家可以去[卡码网第52题](https://kamacoder.com/problempage.php?pid=1052)去练习。
|
||||
|
||||
## 算法公开课
|
||||
|
||||
**[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[带你学透完全背包问题！ ](https://www.bilibili.com/video/BV1uK411o7c9/)，相信结合视频再看本篇题解，更有助于大家对本题的理解**。
|
||||
|
||||
|
||||
## 思路
|
||||
|
||||
本篇我们不再做五部曲分析，核心内容 在 01背包二维 、01背包一维 和 完全背包二维 的讲解中都讲过了。
|
||||
|
||||
上一篇我们刚刚讲了完全背包二维DP数组的写法：
|
||||
|
||||
```CPP
|
||||
for (int i = 1; i < n; i++) { // 遍历物品
|
||||
for(int j = 0; j <= bagWeight; j++) { // 遍历背包容量
|
||||
if (j < weight[i]) dp[i][j] = dp[i - 1][j];
|
||||
else dp[i][j] = max(dp[i - 1][j], dp[i][j - weight[i]] + value[i]);
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
压缩成一维DP数组，也就是将上一层拷贝到当前层。
|
||||
|
||||
将上一层dp[i-1] 的那一层拷贝到 当前层 dp[i] ，那么 递推公式由：`dp[i][j] = max(dp[i - 1][j], dp[i][j - weight[i]] + value[i])` 变成： `dp[i][j] = max(dp[i][j], dp[i][j - weight[i]] + value[i])`
|
||||
|
||||
这里有录友想，这样拷贝的话， dp[i - 1][j] 的数值会不会 覆盖了 dp[i][j] 的数值呢？
|
||||
|
||||
并不会，因为 当前层 dp[i][j] 是空的，是没有计算过的。
|
||||
|
||||
变成 `dp[i][j] = max(dp[i][j], dp[i][j - weight[i]] + value[i])` 我们压缩成一维dp数组，去掉 i 层数维度。
|
||||
|
||||
即：`dp[j] = max(dp[j], dp[j - weight[i]] + value[i])`
|
||||
|
||||
|
||||
接下来我们重点讲一下遍历顺序。
|
||||
|
||||
看过这两篇的话：
|
||||
|
||||
* [01背包理论基础（二维数组）](https://programmercarl.com/背包理论基础01背包-1.html)
|
||||
* [01背包理论基础（一维数组）](https://programmercarl.com/背包理论基础01背包-2.html)
|
||||
|
||||
就知道了，01背包中二维dp数组的两个for遍历的先后循序是可以颠倒了，一维dp数组的两个for循环先后循序一定是先遍历物品，再遍历背包容量。
|
||||
|
||||
**在完全背包中，对于一维dp数组来说，其实两个for循环嵌套顺序是无所谓的**！
|
||||
|
||||
因为dp[j] 是根据 下标j之前所对应的dp[j]计算出来的。 只要保证下标j之前的dp[j]都是经过计算的就可以了。
|
||||
|
||||
遍历物品在外层循环，遍历背包容量在内层循环，状态如图：
|
||||
|
||||
|
||||
|
||||
遍历背包容量在外层循环，遍历物品在内层循环，状态如图：
|
||||
|
||||
|
||||
|
||||
看了这两个图，大家就会理解，完全背包中，两个for循环的先后循序，都不影响计算dp[j]所需要的值（这个值就是下标j之前所对应的dp[j]）。
|
||||
|
||||
先遍历背包再遍历物品，代码如下：
|
||||
|
||||
```CPP
|
||||
for(int j = 0; j <= bagWeight; j++) { // 遍历背包容量
|
||||
for(int i = 0; i < weight.size(); i++) { // 遍历物品
|
||||
if (j - weight[i] >= 0) dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
|
||||
}
|
||||
cout << endl;
|
||||
}
|
||||
```
|
||||
|
||||
先遍历物品再遍历背包：
|
||||
|
||||
```CPP
|
||||
for(int i = 0; i < weight.size(); i++) { // 遍历物品
|
||||
for(int j = 0; j <= bagWeight; j++) { // 遍历背包容量
|
||||
if (j - weight[i] >= 0) dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
整体代码如下：
|
||||
|
||||
```cpp
|
||||
#include <iostream>
|
||||
#include <vector>
|
||||
using namespace std;
|
||||
|
||||
int main() {
|
||||
int N, bagWeight;
|
||||
cin >> N >> bagWeight;
|
||||
vector<int> weight(N, 0);
|
||||
vector<int> value(N, 0);
|
||||
for (int i = 0; i < N; i++) {
|
||||
int w;
|
||||
int v;
|
||||
cin >> w >> v;
|
||||
weight[i] = w;
|
||||
value[i] = v;
|
||||
}
|
||||
|
||||
vector<int> dp(bagWeight + 1, 0);
|
||||
for(int j = 0; j <= bagWeight; j++) { // 遍历背包容量
|
||||
for(int i = 0; i < weight.size(); i++) { // 遍历物品
|
||||
if (j - weight[i] >= 0) dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
|
||||
}
|
||||
}
|
||||
cout << dp[bagWeight] << endl;
|
||||
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
|
||||
## 总结
|
||||
|
||||
细心的同学可能发现，**全文我说的都是对于纯完全背包问题，其for循环的先后循环是可以颠倒的！**
|
||||
|
||||
但如果题目稍稍有点变化，就会体现在遍历顺序上。
|
||||
|
||||
如果问装满背包有几种方式的话？ 那么两个for循环的先后顺序就有很大区别了，而leetcode上的题目都是这种稍有变化的类型。
|
||||
|
||||
这个区别，我将在后面讲解具体leetcode题目中给大家介绍，因为这块如果不结合具题目，单纯的介绍原理估计很多同学会越看越懵！
|
||||
|
||||
别急，下一篇就是了！
|
||||
|
||||
最后，**又可以出一道面试题了，就是纯完全背包，要求先用二维dp数组实现，然后再用一维dp数组实现，最后再问，两个for循环的先后是否可以颠倒？为什么？**
|
||||
|
||||
这个简单的完全背包问题，估计就可以难住不少候选人了。
|
||||
|
||||
|
||||
## 其他语言版本
|
||||
|
||||
### Java：
|
||||
|
||||
```java
|
||||
import java.util.Scanner;
|
||||
|
||||
public class Main {
|
||||
public static void main(String[] args) {
|
||||
Scanner scanner = new Scanner(System.in);
|
||||
int N = scanner.nextInt();
|
||||
int bagWeight = scanner.nextInt();
|
||||
|
||||
int[] weight = new int[N];
|
||||
int[] value = new int[N];
|
||||
for (int i = 0; i < N; i++) {
|
||||
weight[i] = scanner.nextInt();
|
||||
value[i] = scanner.nextInt();
|
||||
}
|
||||
|
||||
int[] dp = new int[bagWeight + 1];
|
||||
|
||||
for (int j = 0; j <= bagWeight; j++) { // 遍历背包容量
|
||||
for (int i = 0; i < weight.length; i++) { // 遍历物品
|
||||
if (j >= weight[i]) {
|
||||
dp[j] = Math.max(dp[j], dp[j - weight[i]] + value[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
System.out.println(dp[bagWeight]);
|
||||
scanner.close();
|
||||
}
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
|
||||
|
||||
### Python：
|
||||
|
||||
```python
|
||||
def complete_knapsack(N, bag_weight, weight, value):
|
||||
dp = [0] * (bag_weight + 1)
|
||||
|
||||
for j in range(bag_weight + 1): # 遍历背包容量
|
||||
for i in range(len(weight)): # 遍历物品
|
||||
if j >= weight[i]:
|
||||
dp[j] = max(dp[j], dp[j - weight[i]] + value[i])
|
||||
|
||||
return dp[bag_weight]
|
||||
|
||||
# 输入
|
||||
N, bag_weight = map(int, input().split())
|
||||
weight = []
|
||||
value = []
|
||||
for _ in range(N):
|
||||
w, v = map(int, input().split())
|
||||
weight.append(w)
|
||||
value.append(v)
|
||||
|
||||
# 输出结果
|
||||
print(complete_knapsack(N, bag_weight, weight, value))
|
||||
|
||||
|
||||
```
|
||||
|
||||
|
||||
### Go：
|
||||
|
||||
```go
|
||||
|
||||
```
|
||||
### Javascript:
|
||||
|
||||
```Javascript
|
||||
```
|
||||
|
||||
@ -5,18 +5,11 @@
|
||||
<p align="center"><strong><a href="./qita/join.md">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们受益！</strong></p>
|
||||
|
||||
|
||||
# 动态规划：完全背包理论基础
|
||||
# 完全背包理论基础-二维DP数组
|
||||
|
||||
本题力扣上没有原题，大家可以去[卡码网第52题](https://kamacoder.com/problempage.php?pid=1052)去练习，题意是一样的。
|
||||
|
||||
## 算法公开课
|
||||
|
||||
**[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[带你学透完全背包问题！ ](https://www.bilibili.com/video/BV1uK411o7c9/)，相信结合视频再看本篇题解，更有助于大家对本题的理解**。
|
||||
|
||||
## 思路
|
||||
|
||||
### 完全背包
|
||||
|
||||
## 完全背包
|
||||
|
||||
有N件物品和一个最多能背重量为W的背包。第i件物品的重量是weight[i]，得到的价值是value[i] 。**每件物品都有无限个（也就是可以放入背包多次）**，求解将哪些物品装入背包里物品价值总和最大。
|
||||
|
||||
@ -24,14 +17,12 @@
|
||||
|
||||
同样leetcode上没有纯完全背包问题，都是需要完全背包的各种应用，需要转化成完全背包问题，所以我这里还是以纯完全背包问题进行讲解理论和原理。
|
||||
|
||||
在下面的讲解中，我依然举这个例子：
|
||||
在下面的讲解中，我拿下面数据举例子：
|
||||
|
||||
背包最大重量为4。
|
||||
|
||||
物品为：
|
||||
背包最大重量为4，物品为：
|
||||
|
||||
| | 重量 | 价值 |
|
||||
| --- | --- | --- |
|
||||
| ----- | ---- | ---- |
|
||||
| 物品0 | 1 | 15 |
|
||||
| 物品1 | 3 | 20 |
|
||||
| 物品2 | 4 | 30 |
|
||||
@ -40,471 +31,292 @@
|
||||
|
||||
问背包能背的物品最大价值是多少？
|
||||
|
||||
01背包和完全背包唯一不同就是体现在遍历顺序上，所以本文就不去做动规五部曲了，我们直接针对遍历顺序经行分析！
|
||||
**如果没看到之前的01背包讲解，已经要先仔细看如下两篇，01背包是基础，本篇在讲解完全背包，之前的背包基础我将不会重复讲解**。
|
||||
|
||||
关于01背包我如下两篇已经进行深入分析了：
|
||||
* [01背包理论基础（二维数组）](https://programmercarl.com/背包理论基础01背包-1.html)
|
||||
* [01背包理论基础（一维数组）](https://programmercarl.com/背包理论基础01背包-2.html)
|
||||
|
||||
* [动态规划：关于01背包问题，你该了解这些！](https://programmercarl.com/背包理论基础01背包-1.html)
|
||||
* [动态规划：关于01背包问题，你该了解这些！（滚动数组）](https://programmercarl.com/背包理论基础01背包-2.html)
|
||||
动规五部曲分析完全背包，为了从原理上讲清楚，我们先从二维dp数组分析：
|
||||
|
||||
首先再回顾一下01背包的核心代码
|
||||
```cpp
|
||||
for(int i = 0; i < weight.size(); i++) { // 遍历物品
|
||||
for(int j = bagWeight; j >= weight[i]; j--) { // 遍历背包容量
|
||||
dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
|
||||
}
|
||||
### 1. 确定dp数组以及下标的含义
|
||||
|
||||
**dp[i][j] 表示从下标为[0-i]的物品，每个物品可以取无限次，放进容量为j的背包，价值总和最大是多少**。
|
||||
|
||||
很多录友也会疑惑，凭什么上来就定义 dp数组，思考过程是什么样的， 这个思考过程我在 [01背包理论基础（二维数组）](https://programmercarl.com/背包理论基础01背包-1.html) 中的 “确定dp数组以及下标的含义” 有详细讲解。
|
||||
|
||||
|
||||
### 2. 确定递推公式
|
||||
|
||||
这里在把基本信息给出来：
|
||||
|
||||
| | 重量 | 价值 |
|
||||
| ----- | ---- | ---- |
|
||||
| 物品0 | 1 | 15 |
|
||||
| 物品1 | 3 | 20 |
|
||||
| 物品2 | 4 | 30 |
|
||||
|
||||
对于递推公式，首先我们要明确有哪些方向可以推导出 dp[i][j]。
|
||||
|
||||
这里依然拿dp[1][4]的状态来举例： （[01背包理论基础（二维数组）](https://programmercarl.com/背包理论基础01背包-1.html) 中也是这个例子，要注意下面的不同之处）
|
||||
|
||||
求取 dp[1][4] 有两种情况：
|
||||
|
||||
1. 放物品1
|
||||
2. 还是不放物品1
|
||||
|
||||
如果不放物品1， 那么背包的价值应该是 dp[0][4] 即 容量为4的背包，只放物品0的情况。
|
||||
|
||||
推导方向如图：
|
||||
|
||||
|
||||
|
||||
如果放物品1， **那么背包要先留出物品1的容量**，目前容量是4，物品1 的容量（就是物品1的重量）为3，此时背包剩下容量为1。
|
||||
|
||||
容量为1，只考虑放物品0 和物品1 的最大价值是 dp[1][1]， **注意 这里和 [01背包理论基础（二维数组）](https://programmercarl.com/背包理论基础01背包-1.html) 有所不同了**！
|
||||
|
||||
在 [01背包理论基础（二维数组）](https://programmercarl.com/背包理论基础01背包-1.html) 中，背包先空留出物品1的容量，此时容量为1，只考虑放物品0的最大价值是 dp[0][1]，**因为01背包每个物品只有一个，既然空出物品1，那背包中也不会再有物品1**！
|
||||
|
||||
而在完全背包中，物品是可以放无限个，所以 即使空出物品1空间重量，那背包中也可能还有物品1，所以此时我们依然考虑放 物品0 和 物品1 的最大价值即： **dp[1][1]， 而不是 dp[0][1]**
|
||||
|
||||
所以 放物品1 的情况 = dp[1][1] + 物品1 的价值，推导方向如图：
|
||||
|
||||
|
||||
|
||||
|
||||
（**注意上图和 [01背包理论基础（二维数组）](https://programmercarl.com/背包理论基础01背包-1.html) 中的区别**，对于理解完全背包很重要）
|
||||
|
||||
两种情况，分别是放物品1 和 不放物品1，我们要取最大值（毕竟求的是最大价值）
|
||||
|
||||
`dp[1][4] = max(dp[0][4], dp[1][1] + 物品1 的价值) `
|
||||
|
||||
以上过程，抽象化如下：
|
||||
|
||||
* **不放物品i**：背包容量为j，里面不放物品i的最大价值是dp[i - 1][j]。
|
||||
|
||||
* **放物品i**：背包空出物品i的容量后，背包容量为j - weight[i]，dp[i][j - weight[i]] 为背包容量为j - weight[i]且不放物品i的最大价值，那么dp[i][j - weight[i]] + value[i] （物品i的价值），就是背包放物品i得到的最大价值
|
||||
|
||||
递推公式： `dp[i][j] = max(dp[i - 1][j], dp[i][j - weight[i]] + value[i]);`
|
||||
|
||||
（注意，完全背包二维dp数组 和 01背包二维dp数组 递推公式的区别，01背包中是 `dp[i - 1][j - weight[i]] + value[i])`）
|
||||
|
||||
### 3. dp数组如何初始化
|
||||
|
||||
**关于初始化，一定要和dp数组的定义吻合，否则到递推公式的时候就会越来越乱**。
|
||||
|
||||
首先从dp[i][j]的定义出发，如果背包容量j为0的话，即dp[i][0]，无论是选取哪些物品，背包价值总和一定为0。如图：
|
||||
|
||||
|
||||
|
||||
在看其他情况。
|
||||
|
||||
状态转移方程 `dp[i][j] = max(dp[i - 1][j], dp[i][j - weight[i]] + value[i]);` 可以看出有一个方向 i 是由 i-1 推导出来，那么i为0的时候就一定要初始化。
|
||||
|
||||
dp[0][j]，即：存放编号0的物品的时候，各个容量的背包所能存放的最大价值。
|
||||
|
||||
那么很明显当 `j < weight[0]`的时候，dp[0][j] 应该是 0，因为背包容量比编号0的物品重量还小。
|
||||
|
||||
当`j >= weight[0]`时，**dp[0][j] 如果能放下weight[0]的话，就一直装，每一种物品有无限个**。
|
||||
|
||||
代码初始化如下：
|
||||
|
||||
```CPP
|
||||
for (int i = 1; i < weight.size(); i++) { // 当然这一步，如果把dp数组预先初始化为0了，这一步就可以省略，但很多同学应该没有想清楚这一点。
|
||||
dp[i][0] = 0;
|
||||
}
|
||||
|
||||
// 正序遍历，如果能放下就一直装物品0
|
||||
for (int j = weight[0]; j <= bagWeight; j++)
|
||||
dp[0][j] = dp[0][j - weight[0]] + value[0];
|
||||
```
|
||||
|
||||
（注意上面初始化和 [01背包理论基础（二维数组）](https://programmercarl.com/背包理论基础01背包-1.html)的区别在于物品有无限个）
|
||||
|
||||
|
||||
此时dp数组初始化情况如图所示：
|
||||
|
||||
|
||||
|
||||
dp[0][j] 和 dp[i][0] 都已经初始化了，那么其他下标应该初始化多少呢？
|
||||
|
||||
其实从递归公式： dp[i][j] = max(dp[i - 1][j], dp[i][j - weight[i]] + value[i]); 可以看出dp[i][j] 是由上方和左方数值推导出来了，那么 其他下标初始为什么数值都可以，因为都会被覆盖。
|
||||
|
||||
但只不过一开始就统一把dp数组统一初始为0，更方便一些。
|
||||
|
||||
最后初始化代码如下：
|
||||
|
||||
```CPP
|
||||
// 初始化 dp
|
||||
vector<vector<int>> dp(weight.size(), vector<int>(bagweight + 1, 0));
|
||||
for (int j = weight[0]; j <= bagWeight; j++) {
|
||||
dp[0][j] = dp[0][j - weight[0]] + value[0];
|
||||
}
|
||||
```
|
||||
|
||||
我们知道01背包内嵌的循环是从大到小遍历，为了保证每个物品仅被添加一次。
|
||||
|
||||
而完全背包的物品是可以添加多次的，所以要从小到大去遍历，即：
|
||||
### 4. 确定遍历顺序
|
||||
|
||||
```CPP
|
||||
// 先遍历物品，再遍历背包
|
||||
for(int i = 0; i < weight.size(); i++) { // 遍历物品
|
||||
for(int j = weight[i]; j <= bagWeight ; j++) { // 遍历背包容量
|
||||
dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
|
||||
[01背包理论基础（二维数组）](https://programmercarl.com/背包理论基础01背包-1.html) 中我们讲过，01背包二维DP数组，先遍历物品还是先遍历背包都是可以的。
|
||||
|
||||
}
|
||||
}
|
||||
```
|
||||
因为两种遍历顺序，对于二维dp数组来说，递推公式所需要的值，二维dp数组里对应的位置都有。
|
||||
|
||||
至于为什么，我在[动态规划：关于01背包问题，你该了解这些！（滚动数组）](https://programmercarl.com/背包理论基础01背包-2.html)中也做了讲解。
|
||||
详细可以看 [01背包理论基础（二维数组）](https://programmercarl.com/背包理论基础01背包-1.html) 中的 【遍历顺序】的讲解
|
||||
|
||||
dp状态图如下：
|
||||
|
||||
|
||||
|
||||
|
||||
相信很多同学看网上的文章，关于完全背包介绍基本就到为止了。
|
||||
|
||||
**其实还有一个很重要的问题，为什么遍历物品在外层循环，遍历背包容量在内层循环？**
|
||||
|
||||
这个问题很多题解关于这里都是轻描淡写就略过了，大家都默认 遍历物品在外层，遍历背包容量在内层，好像本应该如此一样，那么为什么呢？
|
||||
|
||||
难道就不能遍历背包容量在外层，遍历物品在内层？
|
||||
|
||||
|
||||
看过这两篇的话：
|
||||
* [动态规划：关于01背包问题，你该了解这些！](https://programmercarl.com/背包理论基础01背包-1.html)
|
||||
* [动态规划：关于01背包问题，你该了解这些！（滚动数组）](https://programmercarl.com/背包理论基础01背包-2.html)
|
||||
|
||||
就知道了，01背包中二维dp数组的两个for遍历的先后循序是可以颠倒了，一维dp数组的两个for循环先后循序一定是先遍历物品，再遍历背包容量。
|
||||
|
||||
**在完全背包中，对于一维dp数组来说，其实两个for循环嵌套顺序是无所谓的！**
|
||||
|
||||
因为dp[j] 是根据 下标j之前所对应的dp[j]计算出来的。 只要保证下标j之前的dp[j]都是经过计算的就可以了。
|
||||
|
||||
遍历物品在外层循环，遍历背包容量在内层循环，状态如图：
|
||||
|
||||
|
||||
|
||||
|
||||
遍历背包容量在外层循环，遍历物品在内层循环，状态如图：
|
||||
|
||||
|
||||
|
||||
看了这两个图，大家就会理解，完全背包中，两个for循环的先后循序，都不影响计算dp[j]所需要的值（这个值就是下标j之前所对应的dp[j]）。
|
||||
|
||||
先遍历背包在遍历物品，代码如下：
|
||||
|
||||
```CPP
|
||||
// 先遍历背包，再遍历物品
|
||||
for(int j = 0; j <= bagWeight; j++) { // 遍历背包容量
|
||||
for(int i = 0; i < weight.size(); i++) { // 遍历物品
|
||||
if (j - weight[i] >= 0) dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
|
||||
}
|
||||
cout << endl;
|
||||
}
|
||||
```
|
||||
|
||||
完整的C++测试代码如下：
|
||||
|
||||
```CPP
|
||||
// 先遍历物品，在遍历背包
|
||||
void test_CompletePack() {
|
||||
vector<int> weight = {1, 3, 4};
|
||||
vector<int> value = {15, 20, 30};
|
||||
int bagWeight = 4;
|
||||
vector<int> dp(bagWeight + 1, 0);
|
||||
for(int i = 0; i < weight.size(); i++) { // 遍历物品
|
||||
for(int j = weight[i]; j <= bagWeight; j++) { // 遍历背包容量
|
||||
dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
|
||||
}
|
||||
}
|
||||
cout << dp[bagWeight] << endl;
|
||||
}
|
||||
int main() {
|
||||
test_CompletePack();
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
```CPP
|
||||
|
||||
// 先遍历背包，再遍历物品
|
||||
void test_CompletePack() {
|
||||
vector<int> weight = {1, 3, 4};
|
||||
vector<int> value = {15, 20, 30};
|
||||
int bagWeight = 4;
|
||||
|
||||
vector<int> dp(bagWeight + 1, 0);
|
||||
所以既可以 先遍历物品再遍历背包：
|
||||
|
||||
```CPP
|
||||
for (int i = 1; i < n; i++) { // 遍历物品
|
||||
for(int j = 0; j <= bagWeight; j++) { // 遍历背包容量
|
||||
for(int i = 0; i < weight.size(); i++) { // 遍历物品
|
||||
if (j - weight[i] >= 0) dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
|
||||
}
|
||||
if (j < weight[i]) dp[i][j] = dp[i - 1][j];
|
||||
else dp[i][j] = max(dp[i - 1][j], dp[i][j - weight[i]] + value[i]);
|
||||
}
|
||||
cout << dp[bagWeight] << endl;
|
||||
}
|
||||
int main() {
|
||||
test_CompletePack();
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
本题力扣上没有原题，大家可以去[卡码网第52题](https://kamacoder.com/problempage.php?pid=1052)去练习，题意是一样的，C++代码如下：
|
||||
也可以 先遍历背包再遍历物品：
|
||||
|
||||
```cpp
|
||||
```CPP
|
||||
for(int j = 0; j <= bagWeight; j++) { // 遍历背包容量
|
||||
for (int i = 1; i < n; i++) { // 遍历物品
|
||||
if (j < weight[i]) dp[i][j] = dp[i - 1][j];
|
||||
else dp[i][j] = max(dp[i - 1][j], dp[i][j - weight[i]] + value[i]);
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### 5. 举例推导dp数组
|
||||
|
||||
以本篇举例数据为例，填满了dp二维数组如图：
|
||||
|
||||
|
||||
|
||||
因为 物品0 的性价比是最高的，而且 在完全背包中，每一类物品都有无限个，所以有无限个物品0，既然物品0 性价比最高，当然是优先放物品0。
|
||||
|
||||
|
||||
### 本题代码：
|
||||
|
||||
|
||||
```CPP
|
||||
#include <iostream>
|
||||
#include <vector>
|
||||
using namespace std;
|
||||
|
||||
// 先遍历背包，再遍历物品
|
||||
void test_CompletePack(vector<int> weight, vector<int> value, int bagWeight) {
|
||||
int main() {
|
||||
int n, bagWeight;
|
||||
int w, v;
|
||||
cin >> n >> bagWeight;
|
||||
vector<int> weight(n);
|
||||
vector<int> value(n);
|
||||
for (int i = 0; i < n; i++) {
|
||||
cin >> weight[i] >> value[i];
|
||||
}
|
||||
|
||||
vector<int> dp(bagWeight + 1, 0);
|
||||
vector<vector<int>> dp(n, vector<int>(bagWeight + 1, 0));
|
||||
|
||||
for(int j = 0; j <= bagWeight; j++) { // 遍历背包容量
|
||||
for(int i = 0; i < weight.size(); i++) { // 遍历物品
|
||||
if (j - weight[i] >= 0) dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
|
||||
// 初始化
|
||||
for (int j = weight[0]; j <= bagWeight; j++)
|
||||
dp[0][j] = dp[0][j - weight[0]] + value[0];
|
||||
|
||||
for (int i = 1; i < n; i++) { // 遍历物品
|
||||
for(int j = 0; j <= bagWeight; j++) { // 遍历背包容量
|
||||
if (j < weight[i]) dp[i][j] = dp[i - 1][j];
|
||||
else dp[i][j] = max(dp[i - 1][j], dp[i][j - weight[i]] + value[i]);
|
||||
}
|
||||
}
|
||||
cout << dp[bagWeight] << endl;
|
||||
}
|
||||
int main() {
|
||||
int N, V;
|
||||
cin >> N >> V;
|
||||
vector<int> weight;
|
||||
vector<int> value;
|
||||
for (int i = 0; i < N; i++) {
|
||||
int w;
|
||||
int v;
|
||||
cin >> w >> v;
|
||||
weight.push_back(w);
|
||||
value.push_back(v);
|
||||
}
|
||||
test_CompletePack(weight, value, V);
|
||||
|
||||
cout << dp[n - 1][bagWeight] << endl;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
|
||||
|
||||
## 总结
|
||||
|
||||
细心的同学可能发现，**全文我说的都是对于纯完全背包问题，其for循环的先后循环是可以颠倒的！**
|
||||
|
||||
但如果题目稍稍有点变化，就会体现在遍历顺序上。
|
||||
|
||||
如果问装满背包有几种方式的话？ 那么两个for循环的先后顺序就有很大区别了，而leetcode上的题目都是这种稍有变化的类型。
|
||||
|
||||
这个区别，我将在后面讲解具体leetcode题目中给大家介绍，因为这块如果不结合具题目，单纯的介绍原理估计很多同学会越看越懵！
|
||||
|
||||
别急，下一篇就是了！
|
||||
|
||||
最后，**又可以出一道面试题了，就是纯完全背包，要求先用二维dp数组实现，然后再用一维dp数组实现，最后再问，两个for循环的先后是否可以颠倒？为什么？**
|
||||
这个简单的完全背包问题，估计就可以难住不少候选人了。
|
||||
|
||||
|
||||
|
||||
关于一维dp数组，大家看这里：[完全背包一维dp数组讲解](./背包问题完全背包一维.md)
|
||||
|
||||
## 其他语言版本
|
||||
|
||||
### Java：
|
||||
### Java
|
||||
|
||||
```java
|
||||
//先遍历物品，再遍历背包
|
||||
private static void testCompletePack(){
|
||||
int[] weight = {1, 3, 4};
|
||||
int[] value = {15, 20, 30};
|
||||
int bagWeight = 4;
|
||||
int[] dp = new int[bagWeight + 1];
|
||||
for (int i = 0; i < weight.length; i++){ // 遍历物品
|
||||
for (int j = weight[i]; j <= bagWeight; j++){ // 遍历背包容量
|
||||
dp[j] = Math.max(dp[j], dp[j - weight[i]] + value[i]);
|
||||
```Java
|
||||
import java.util.Scanner;
|
||||
|
||||
public class Main {
|
||||
public static void main(String[] args) {
|
||||
Scanner scanner = new Scanner(System.in);
|
||||
int n = scanner.nextInt();
|
||||
int bagWeight = scanner.nextInt();
|
||||
|
||||
int[] weight = new int[n];
|
||||
int[] value = new int[n];
|
||||
|
||||
for (int i = 0; i < n; i++) {
|
||||
weight[i] = scanner.nextInt();
|
||||
value[i] = scanner.nextInt();
|
||||
}
|
||||
}
|
||||
for (int maxValue : dp){
|
||||
System.out.println(maxValue + " ");
|
||||
}
|
||||
}
|
||||
|
||||
//先遍历背包，再遍历物品
|
||||
private static void testCompletePackAnotherWay(){
|
||||
int[] weight = {1, 3, 4};
|
||||
int[] value = {15, 20, 30};
|
||||
int bagWeight = 4;
|
||||
int[] dp = new int[bagWeight + 1];
|
||||
for (int i = 1; i <= bagWeight; i++){ // 遍历背包容量
|
||||
for (int j = 0; j < weight.length; j++){ // 遍历物品
|
||||
if (i - weight[j] >= 0){
|
||||
dp[i] = Math.max(dp[i], dp[i - weight[j]] + value[j]);
|
||||
}
|
||||
int[][] dp = new int[n][bagWeight + 1];
|
||||
|
||||
// 初始化
|
||||
for (int j = weight[0]; j <= bagWeight; j++) {
|
||||
dp[0][j] = dp[0][j - weight[0]] + value[0];
|
||||
}
|
||||
}
|
||||
for (int maxValue : dp){
|
||||
System.out.println(maxValue + " ");
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
|
||||
### Python：
|
||||
|
||||
先遍历物品，再遍历背包（无参版）
|
||||
```python
|
||||
def test_CompletePack():
|
||||
weight = [1, 3, 4]
|
||||
value = [15, 20, 30]
|
||||
bagWeight = 4
|
||||
dp = [0] * (bagWeight + 1)
|
||||
for i in range(len(weight)): # 遍历物品
|
||||
for j in range(weight[i], bagWeight + 1): # 遍历背包容量
|
||||
dp[j] = max(dp[j], dp[j - weight[i]] + value[i])
|
||||
print(dp[bagWeight])
|
||||
|
||||
test_CompletePack()
|
||||
|
||||
```
|
||||
|
||||
先遍历物品，再遍历背包（有参版）
|
||||
```python
|
||||
def test_CompletePack(weight, value, bagWeight):
|
||||
dp = [0] * (bagWeight + 1)
|
||||
for i in range(len(weight)): # 遍历物品
|
||||
for j in range(weight[i], bagWeight + 1): # 遍历背包容量
|
||||
dp[j] = max(dp[j], dp[j - weight[i]] + value[i])
|
||||
return dp[bagWeight]
|
||||
|
||||
if __name__ == "__main__":
|
||||
weight = [1, 3, 4]
|
||||
value = [15, 20, 30]
|
||||
bagWeight = 4
|
||||
result = test_CompletePack(weight, value, bagWeight)
|
||||
print(result)
|
||||
|
||||
```
|
||||
先遍历背包，再遍历物品（无参版）
|
||||
```python
|
||||
def test_CompletePack():
|
||||
weight = [1, 3, 4]
|
||||
value = [15, 20, 30]
|
||||
bagWeight = 4
|
||||
|
||||
dp = [0] * (bagWeight + 1)
|
||||
|
||||
for j in range(bagWeight + 1): # 遍历背包容量
|
||||
for i in range(len(weight)): # 遍历物品
|
||||
if j - weight[i] >= 0:
|
||||
dp[j] = max(dp[j], dp[j - weight[i]] + value[i])
|
||||
|
||||
print(dp[bagWeight])
|
||||
|
||||
test_CompletePack()
|
||||
|
||||
|
||||
```
|
||||
|
||||
先遍历背包，再遍历物品（有参版）
|
||||
```python
|
||||
def test_CompletePack(weight, value, bagWeight):
|
||||
dp = [0] * (bagWeight + 1)
|
||||
for j in range(bagWeight + 1): # 遍历背包容量
|
||||
for i in range(len(weight)): # 遍历物品
|
||||
if j - weight[i] >= 0:
|
||||
dp[j] = max(dp[j], dp[j - weight[i]] + value[i])
|
||||
return dp[bagWeight]
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
weight = [1, 3, 4]
|
||||
value = [15, 20, 30]
|
||||
bagWeight = 4
|
||||
result = test_CompletePack(weight, value, bagWeight)
|
||||
print(result)
|
||||
|
||||
```
|
||||
|
||||
### Go：
|
||||
|
||||
```go
|
||||
|
||||
// test_CompletePack1 先遍历物品, 在遍历背包
|
||||
func test_CompletePack1(weight, value []int, bagWeight int) int {
|
||||
// 定义dp数组 和初始化
|
||||
dp := make([]int, bagWeight+1)
|
||||
// 遍历顺序
|
||||
for i := 0; i < len(weight); i++ {
|
||||
// 正序会多次添加 value[i]
|
||||
for j := weight[i]; j <= bagWeight; j++ {
|
||||
// 推导公式
|
||||
dp[j] = max(dp[j], dp[j-weight[i]]+value[i])
|
||||
// debug
|
||||
//fmt.Println(dp)
|
||||
}
|
||||
}
|
||||
return dp[bagWeight]
|
||||
}
|
||||
|
||||
// test_CompletePack2 先遍历背包, 在遍历物品
|
||||
func test_CompletePack2(weight, value []int, bagWeight int) int {
|
||||
// 定义dp数组 和初始化
|
||||
dp := make([]int, bagWeight+1)
|
||||
// 遍历顺序
|
||||
// j从0 开始
|
||||
for j := 0; j <= bagWeight; j++ {
|
||||
for i := 0; i < len(weight); i++ {
|
||||
if j >= weight[i] {
|
||||
// 推导公式
|
||||
dp[j] = max(dp[j], dp[j-weight[i]]+value[i])
|
||||
}
|
||||
// debug
|
||||
//fmt.Println(dp)
|
||||
}
|
||||
}
|
||||
return dp[bagWeight]
|
||||
}
|
||||
|
||||
func max(a, b int) int {
|
||||
if a > b {
|
||||
return a
|
||||
}
|
||||
return b
|
||||
}
|
||||
|
||||
func main() {
|
||||
weight := []int{1, 3, 4}
|
||||
price := []int{15, 20, 30}
|
||||
fmt.Println(test_CompletePack1(weight, price, 4))
|
||||
fmt.Println(test_CompletePack2(weight, price, 4))
|
||||
}
|
||||
```
|
||||
### JavaScript:
|
||||
|
||||
```Javascript
|
||||
// 先遍历物品，再遍历背包容量
|
||||
function test_completePack1() {
|
||||
let weight = [1, 3, 5]
|
||||
let value = [15, 20, 30]
|
||||
let bagWeight = 4
|
||||
let dp = new Array(bagWeight + 1).fill(0)
|
||||
for(let i = 0; i <= weight.length; i++) {
|
||||
for(let j = weight[i]; j <= bagWeight; j++) {
|
||||
dp[j] = Math.max(dp[j], dp[j - weight[i]] + value[i])
|
||||
}
|
||||
}
|
||||
console.log(dp)
|
||||
}
|
||||
|
||||
// 先遍历背包容量，再遍历物品
|
||||
function test_completePack2() {
|
||||
let weight = [1, 3, 5]
|
||||
let value = [15, 20, 30]
|
||||
let bagWeight = 4
|
||||
let dp = new Array(bagWeight + 1).fill(0)
|
||||
for(let j = 0; j <= bagWeight; j++) {
|
||||
for(let i = 0; i < weight.length; i++) {
|
||||
if (j >= weight[i]) {
|
||||
dp[j] = Math.max(dp[j], dp[j - weight[i]] + value[i])
|
||||
}
|
||||
}
|
||||
}
|
||||
console.log(2, dp);
|
||||
}
|
||||
```
|
||||
|
||||
### TypeScript：
|
||||
|
||||
```typescript
|
||||
// 先遍历物品，再遍历背包容量
|
||||
function test_CompletePack(): void {
|
||||
const weight: number[] = [1, 3, 4];
|
||||
const value: number[] = [15, 20, 30];
|
||||
const bagSize: number = 4;
|
||||
const dp: number[] = new Array(bagSize + 1).fill(0);
|
||||
for (let i = 0; i < weight.length; i++) {
|
||||
for (let j = weight[i]; j <= bagSize; j++) {
|
||||
dp[j] = Math.max(dp[j], dp[j - weight[i]] + value[i]);
|
||||
}
|
||||
}
|
||||
console.log(dp);
|
||||
}
|
||||
test_CompletePack();
|
||||
```
|
||||
|
||||
### Scala:
|
||||
|
||||
```scala
|
||||
// 先遍历物品，再遍历背包容量
|
||||
object Solution {
|
||||
def test_CompletePack() {
|
||||
var weight = Array[Int](1, 3, 4)
|
||||
var value = Array[Int](15, 20, 30)
|
||||
var baseweight = 4
|
||||
|
||||
var dp = new Array[Int](baseweight + 1)
|
||||
|
||||
for (i <- 0 until weight.length) {
|
||||
for (j <- weight(i) to baseweight) {
|
||||
dp(j) = math.max(dp(j), dp(j - weight(i)) + value(i))
|
||||
}
|
||||
}
|
||||
dp(baseweight)
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### Rust:
|
||||
|
||||
```rust
|
||||
impl Solution {
|
||||
// 先遍历物品
|
||||
fn complete_pack() {
|
||||
let (goods, bag_size) = (vec![(1, 15), (3, 20), (4, 30)], 4);
|
||||
let mut dp = vec![0; bag_size + 1];
|
||||
for (weight, value) in goods {
|
||||
for j in weight..=bag_size {
|
||||
dp[j] = dp[j].max(dp[j - weight] + value);
|
||||
}
|
||||
}
|
||||
println!("先遍历物品：{}", dp[bag_size]);
|
||||
}
|
||||
|
||||
// 先遍历背包
|
||||
fn complete_pack_after() {
|
||||
let (goods, bag_size) = (vec![(1, 15), (3, 20), (4, 30)], 4);
|
||||
let mut dp = vec![0; bag_size + 1];
|
||||
for i in 0..=bag_size {
|
||||
for (weight, value) in &goods {
|
||||
if i >= *weight {
|
||||
dp[i] = dp[i].max(dp[i - weight] + value);
|
||||
// 动态规划
|
||||
for (int i = 1; i < n; i++) {
|
||||
for (int j = 0; j <= bagWeight; j++) {
|
||||
if (j < weight[i]) {
|
||||
dp[i][j] = dp[i - 1][j];
|
||||
} else {
|
||||
dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - weight[i]] + value[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
println!("先遍历背包：{}", dp[bag_size]);
|
||||
|
||||
System.out.println(dp[n - 1][bagWeight]);
|
||||
scanner.close();
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_complete_pack() {
|
||||
Solution::complete_pack();
|
||||
Solution::complete_pack_after();
|
||||
}
|
||||
```
|
||||
|
||||
### Go
|
||||
|
||||
### Python
|
||||
|
||||
```python
|
||||
def knapsack(n, bag_weight, weight, value):
|
||||
dp = [[0] * (bag_weight + 1) for _ in range(n)]
|
||||
|
||||
# 初始化
|
||||
for j in range(weight[0], bag_weight + 1):
|
||||
dp[0][j] = dp[0][j - weight[0]] + value[0]
|
||||
|
||||
# 动态规划
|
||||
for i in range(1, n):
|
||||
for j in range(bag_weight + 1):
|
||||
if j < weight[i]:
|
||||
dp[i][j] = dp[i - 1][j]
|
||||
else:
|
||||
dp[i][j] = max(dp[i - 1][j], dp[i][j - weight[i]] + value[i])
|
||||
|
||||
return dp[n - 1][bag_weight]
|
||||
|
||||
# 输入
|
||||
n, bag_weight = map(int, input().split())
|
||||
weight = []
|
||||
value = []
|
||||
for _ in range(n):
|
||||
w, v = map(int, input().split())
|
||||
weight.append(w)
|
||||
value.append(v)
|
||||
|
||||
# 输出结果
|
||||
print(knapsack(n, bag_weight, weight, value))
|
||||
|
||||
```
|
||||
|
||||
### JavaScript
|
||||
|
||||
|
||||
|
||||
<p align="center">
|
||||
<a href="https://programmercarl.com/other/kstar.html" target="_blank">
|
||||
|
||||
@ -78,7 +78,7 @@
|
||||
* 求解每一个子问题的最优解
|
||||
* 将局部最优解堆叠成全局最优解
|
||||
|
||||
这个四步其实过于理论化了，我们平时在做贪心类的题目 很难去按照这四步去思考，真是有点“鸡肋”。
|
||||
这个四步其实过于理论化了，我们平时在做贪心类的题目时，如果按照这四步去思考，真是有点“鸡肋”。
|
||||
|
||||
做题的时候，只要想清楚 局部最优 是什么，如果推导出全局最优，其实就够了。
|
||||
|
||||
|
||||
Reference in New Issue
Block a user