diff --git a/README.md b/README.md index b326046e..b1db51c9 100644 --- a/README.md +++ b/README.md @@ -299,24 +299,25 @@ 背包问题大纲 -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 @@ （持续更新中....） - -## 十大排序 - -## 数论 - -## 高级数据结构经典题目 - -* 并查集 -* 最小生成树 -* 线段树 -* 树状数组 -* 字典树 - -## 海量数据处理 - # 补充题目 以上题目是重中之重，大家至少要刷两遍以上才能彻底理解，如果熟练以上题目之后还在找其他题目练手，可以再刷以下题目： diff --git a/problems/0015.三数之和.md b/problems/0015.三数之和.md index f7146907..1685db74 100644 --- a/problems/0015.三数之和.md +++ b/problems/0015.三数之和.md @@ -34,7 +34,7 @@ ### 哈希解法 -两层for循环就可以确定 a 和b 的数值了，可以使用哈希法来确定 0-(a+b) 是否在 数组里出现过，其实这个思路是正确的，但是我们有一个非常棘手的问题，就是题目中说的不可以包含重复的三元组。 +两层for循环就可以确定 两个数值，可以使用哈希法来确定 第三个数 0-(a+b) 或者 0 - (a + c) 是否在 数组里出现过，其实这个思路是正确的，但是我们有一个非常棘手的问题，就是题目中说的不可以包含重复的三元组。 把符合条件的三元组放进vector中，然后再去重，这样是非常费时的，很容易超时，也是这道题目通过率如此之低的根源所在。 @@ -48,35 +48,41 @@ ```CPP class Solution { public: + // 在一个数组中找到3个数形成的三元组，它们的和为0，不能重复使用（三数下标互不相同），且三元组不能重复。 + // b（存储）== 0-(a+c)（检索） vector> threeSum(vector& nums) { vector> 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 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 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; } }; diff --git a/problems/0019.删除链表的倒数第N个节点.md b/problems/0019.删除链表的倒数第N个节点.md index f0ef2366..fafef1f2 100644 --- a/problems/0019.删除链表的倒数第N个节点.md +++ b/problems/0019.删除链表的倒数第N个节点.md @@ -58,7 +58,7 @@ * fast和slow同时移动，直到fast指向末尾，如题： - +//图片中有错别词：应该将“只到”改为“直到” * 删除slow指向的下一个节点，如图： diff --git a/problems/0028.实现strStr.md b/problems/0028.实现strStr.md index e0cb123e..63a08d96 100644 --- a/problems/0028.实现strStr.md +++ b/problems/0028.实现strStr.md @@ -1456,6 +1456,70 @@ public int[] GetNext(string needle) } ``` +### C: + +> 前缀表统一右移和减一 + +```c + +int *build_next(char* needle, int len) { + + int *next = (int *)malloc(len * sizeof(int)); + assert(next); // 确保分配成功 + + // 初始化next数组 + next[0] = -1; // next[0] 设置为 -1，表示没有有效前缀匹配 + if (len <= 1) { // 如果模式串长度小于等于 1，直接返回 + return next; + } + next[1] = 0; // next[1] 设置为 0，表示第一个字符没有公共前后缀 + + // 构建next数组， i 从模式串的第三个字符开始， j 指向当前匹配的最长前缀长度 + int i = 2, j = 0; + while (i < len) { + if (needle[i - 1] == needle[j]) { + j++; + next[i] = j; + i++; + } else if (j > 0) { + // 如果不匹配且 j > 0， 回退到次长匹配前缀的长度 + j = next[j]; + } else { + next[i] = 0; + i++; + } + } + return next; +} + +int strStr(char* haystack, char* needle) { + + int needle_len = strlen(needle); + int haystack_len = strlen(haystack); + + int *next = build_next(needle, needle_len); + + int i = 0, j = 0; // i 指向主串的当前起始位置, j 指向模式串的当前匹配位置 + while (i <= haystack_len - needle_len) { + if (haystack[i + j] == needle[j]) { + j++; + if (j == needle_len) { + free(next); + next = NULL + return i; + } + } else { + i += j - next[j]; // 调整主串的起始位置 + j = j > 0 ? next[j] : 0; + } + } + + free(next); + next = NULL; + return -1; +} +``` +

diff --git a/problems/0037.解数独.md b/problems/0037.解数独.md index 6a9f69bd..5f3f881c 100644 --- a/problems/0037.解数独.md +++ b/problems/0037.解数独.md @@ -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 diff --git a/problems/0084.柱状图中最大的矩形.md b/problems/0084.柱状图中最大的矩形.md index c08a3045..5c6f4073 100644 --- a/problems/0084.柱状图中最大的矩形.md +++ b/problems/0084.柱状图中最大的矩形.md @@ -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 { diff --git a/problems/0111.二叉树的最小深度.md b/problems/0111.二叉树的最小深度.md index cd7096ac..708e0532 100644 --- a/problems/0111.二叉树的最小深度.md +++ b/problems/0111.二叉树的最小深度.md @@ -40,7 +40,7 @@ 本题依然是前序遍历和后序遍历都可以，前序求的是深度，后序求的是高度。 * 二叉树节点的深度：指从根节点到该节点的最长简单路径边的条数或者节点数（取决于深度从0开始还是从1开始） -* 二叉树节点的高度：指从该节点到叶子节点的最长简单路径边的条数后者节点数（取决于高度从0开始还是从1开始） +* 二叉树节点的高度：指从该节点到叶子节点的最长简单路径边的条数或者节点数（取决于高度从0开始还是从1开始） 那么使用后序遍历，其实求的是根节点到叶子节点的最小距离，就是求高度的过程，不过这个最小距离 也同样是最小深度。 diff --git a/problems/0143.重排链表.md b/problems/0143.重排链表.md index 87075431..ccddef5b 100644 --- a/problems/0143.重排链表.md +++ b/problems/0143.重排链表.md @@ -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 diff --git a/problems/0150.逆波兰表达式求值.md b/problems/0150.逆波兰表达式求值.md index 7d4031d7..5fb28c29 100644 --- a/problems/0150.逆波兰表达式求值.md +++ b/problems/0150.逆波兰表达式求值.md @@ -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: diff --git a/problems/0203.移除链表元素.md b/problems/0203.移除链表元素.md index c2f1d449..5a4bbb74 100644 --- a/problems/0203.移除链表元素.md +++ b/problems/0203.移除链表元素.md @@ -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 diff --git a/problems/0236.二叉树的最近公共祖先.md b/problems/0236.二叉树的最近公共祖先.md index 8572ec2d..8cd505a8 100644 --- a/problems/0236.二叉树的最近公共祖先.md +++ b/problems/0236.二叉树的最近公共祖先.md @@ -45,7 +45,7 @@ 那么二叉树如何可以自底向上查找呢？ -回溯啊，二叉树回溯的过程就是从低到上。 +回溯啊，二叉树回溯的过程就是从底到上。 后序遍历（左右中）就是天然的回溯过程，可以根据左右子树的返回值，来处理中节点的逻辑。 diff --git a/problems/0332.重新安排行程.md b/problems/0332.重新安排行程.md index ed8149d0..78e14074 100644 --- a/problems/0332.重新安排行程.md +++ b/problems/0332.重新安排行程.md @@ -172,7 +172,7 @@ if (result.size() == ticketNum + 1) { 回溯的过程中，如何遍历一个机场所对应的所有机场呢？ -这里刚刚说过，在选择映射函数的时候，不能选择`unordered_map> targets`， 因为一旦有元素增删multiset的迭代器就会失效，当然可能有牛逼的容器删除元素迭代器不会失效，这里就不在讨论了。 +这里刚刚说过，在选择映射函数的时候，不能选择`unordered_map> targets`， 因为一旦有元素增删multiset的迭代器就会失效，当然可能有牛逼的容器删除元素迭代器不会失效，这里就不再讨论了。 **可以说本题既要找到一个对数据进行排序的容器，而且还要容易增删元素，迭代器还不能失效**。 diff --git a/problems/0376.摆动序列.md b/problems/0376.摆动序列.md index 9cf1ed8c..e2ea9904 100644 --- a/problems/0376.摆动序列.md +++ b/problems/0376.摆动序列.md @@ -72,7 +72,7 @@ #### 情况一：上下坡中有平坡 -例如 [1,2,2,2,1]这样的数组，如图： +例如 [1,2,2,2,2,1]这样的数组，如图： ![](https://code-thinking-1253855093.file.myqcloud.com/pics/20230106170449.png) diff --git a/problems/0450.删除二叉搜索树中的节点.md b/problems/0450.删除二叉搜索树中的节点.md index cab9880a..831655e8 100644 --- a/problems/0450.删除二叉搜索树中的节点.md +++ b/problems/0450.删除二叉搜索树中的节点.md @@ -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 +```

diff --git a/problems/0494.目标和.md b/problems/0494.目标和.md index 206fdf89..6ddf774d 100644 --- a/problems/0494.目标和.md +++ b/problems/0494.目标和.md @@ -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 { diff --git a/problems/0496.下一个更大元素I.md b/problems/0496.下一个更大元素I.md index 54182d30..02e73a58 100644 --- a/problems/0496.下一个更大元素I.md +++ b/problems/0496.下一个更大元素I.md @@ -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 diff --git a/problems/0518.零钱兑换II.md b/problems/0518.零钱兑换II.md index 1921866e..835df852 100644 --- a/problems/0518.零钱兑换II.md +++ b/problems/0518.零钱兑换II.md @@ -4,8 +4,6 @@

参与本项目，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们受益！

- - # 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数组如何初始化 + +那么二维数组的最上行 和 最左列一定要初始化，这是递推公式推导的基础，如图红色部分： + +![](https://code-thinking-1253855093.file.myqcloud.com/pics/20240827103507.png) + + +这里首先要关注的就是 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& coins) { + int bagSize = amount; + + vector> dp(coins.size(), vector(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 - diff --git a/problems/0707.设计链表.md b/problems/0707.设计链表.md index 0cb2f2f2..ed1726d9 100644 --- a/problems/0707.设计链表.md +++ b/problems/0707.设计链表.md @@ -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=size){ + //判断index是否有效 + if(index < 0 || index >= size){ return; } + //删除操作 - size--; - ListNode pre = this.head; - for(int i=0; i 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 diff --git a/problems/0739.每日温度.md b/problems/0739.每日温度.md index 45af5286..dd633aed 100644 --- a/problems/0739.每日温度.md +++ b/problems/0739.每日温度.md @@ -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 diff --git a/problems/0922.按奇偶排序数组II.md b/problems/0922.按奇偶排序数组II.md index 1ac6800c..28680dbf 100644 --- a/problems/0922.按奇偶排序数组II.md +++ b/problems/0922.按奇偶排序数组II.md @@ -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 sortArrayByParityII(vector& A) { - vector even(A.size() / 2); // 初始化就确定数组大小，节省开销 - vector odd(A.size() / 2); - vector result(A.size()); + vector sortArrayByParityII(vector& nums) { + vector even(nums.size() / 2); // 初始化就确定数组大小，节省开销 + vector odd(nums.size() / 2); + vector 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 sortArrayByParityII(vector& A) { - vector result(A.size()); + vector sortArrayByParityII(vector& nums) { + vector 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 sortArrayByParityII(vector& A) { + vector sortArrayByParityII(vector& 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 diff --git a/problems/1049.最后一块石头的重量II.md b/problems/1049.最后一块石头的重量II.md index b40ed114..0d445a71 100644 --- a/problems/1049.最后一块石头的重量II.md +++ b/problems/1049.最后一块石头的重量II.md @@ -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 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)相当于是求背包是否正好装满，而本题是求背包最多能装多少**。 ## 其他语言版本 diff --git a/problems/1365.有多少小于当前数字的数字.md b/problems/1365.有多少小于当前数字的数字.md index 64f61096..f0a77f55 100644 --- a/problems/1365.有多少小于当前数字的数字.md +++ b/problems/1365.有多少小于当前数字的数字.md @@ -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 { diff --git a/problems/kamacoder/0044.开发商购买土地.md b/problems/kamacoder/0044.开发商购买土地.md index ea2c696e..739e2cad 100644 --- a/problems/kamacoder/0044.开发商购买土地.md +++ b/problems/kamacoder/0044.开发商购买土地.md @@ -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 前缀和 diff --git a/problems/kamacoder/0054.替换数字.md b/problems/kamacoder/0054.替换数字.md index 443b8bfb..de0ab1a3 100644 --- a/problems/kamacoder/0054.替换数字.md +++ b/problems/kamacoder/0054.替换数字.md @@ -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"); diff --git a/problems/kamacoder/0095.城市间货物运输II.md b/problems/kamacoder/0095.城市间货物运输II.md index 0e8aac11..a3896b88 100644 --- a/problems/kamacoder/0095.城市间货物运输II.md +++ b/problems/kamacoder/0095.城市间货物运输II.md @@ -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 diff --git a/problems/kamacoder/0096.城市间货物运输III.md b/problems/kamacoder/0096.城市间货物运输III.md index a3e9e840..0e13846d 100644 --- a/problems/kamacoder/0096.城市间货物运输III.md +++ b/problems/kamacoder/0096.城市间货物运输III.md @@ -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> 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 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 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> 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() ``` diff --git a/problems/kamacoder/0097.小明逛公园.md b/problems/kamacoder/0097.小明逛公园.md index 8b3078fc..dfbd6aa9 100644 --- a/problems/kamacoder/0097.小明逛公园.md +++ b/problems/kamacoder/0097.小明逛公园.md @@ -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 diff --git a/problems/kamacoder/0101.孤岛的总面积.md b/problems/kamacoder/0101.孤岛的总面积.md index acb76c3a..123e36ce 100644 --- a/problems/kamacoder/0101.孤岛的总面积.md +++ b/problems/kamacoder/0101.孤岛的总面积.md @@ -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) ``` diff --git a/problems/kamacoder/0103.水流问题.md b/problems/kamacoder/0103.水流问题.md index a09bf089..3066c99f 100644 --- a/problems/kamacoder/0103.水流问题.md +++ b/problems/kamacoder/0103.水流问题.md @@ -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 diff --git a/problems/kamacoder/0105.有向图的完全可达性.md b/problems/kamacoder/0105.有向图的完全可达性.md index 3bfcfb40..6901c655 100644 --- a/problems/kamacoder/0105.有向图的完全可达性.md +++ b/problems/kamacoder/0105.有向图的完全可达性.md @@ -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 diff --git a/problems/kamacoder/0108.冗余连接.md b/problems/kamacoder/0108.冗余连接.md index efbbb6d2..121c2bfd 100644 --- a/problems/kamacoder/0108.冗余连接.md +++ b/problems/kamacoder/0108.冗余连接.md @@ -44,7 +44,7 @@ ![](https://code-thinking-1253855093.file.myqcloud.com/pics/20240527110320.png) -图中的 1 2，2 3，1 3 等三条边在删除后都能使原图变为一棵合法的树。但是 1 3 由于是标准输出里最后出现的那条边，所以输出结果为 1 3 +图中的 1 2，2 3，1 3 等三条边在删除后都能使原图变为一棵合法的树。但是 1 3 由于是标准输入里最后出现的那条边，所以输出结果为 1 3 数据范围： diff --git a/problems/二叉树的统一迭代法.md b/problems/二叉树的统一迭代法.md index 13c50737..037cf110 100644 --- a/problems/二叉树的统一迭代法.md +++ b/problems/二叉树的统一迭代法.md @@ -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 inorderTraversal(TreeNode* root) { + vector result; + stack> 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 postorderTraversal(TreeNode* root) { + vector result; + stack> 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： > 前序遍历统一迭代法 diff --git a/problems/周总结/20201107回溯周末总结.md b/problems/周总结/20201107回溯周末总结.md index 2d20a197..7e333c76 100644 --- a/problems/周总结/20201107回溯周末总结.md +++ b/problems/周总结/20201107回溯周末总结.md @@ -75,7 +75,7 @@ for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target; 除了这些难点，**本题还有细节，例如：切割过的地方不能重复切割所以递归函数需要传入i + 1**。 -所以本题应该是一个道hard题目了。 +所以本题应该是一道hard题目了。 **本题的树形结构中，和代码的逻辑有一个小出入，已经判断不是回文的子串就不会进入递归了，纠正如下：** diff --git a/problems/周总结/20210107动规周末总结.md b/problems/周总结/20210107动规周末总结.md index 4cab00cc..da2ebd30 100644 --- a/problems/周总结/20210107动规周末总结.md +++ b/problems/周总结/20210107动规周末总结.md @@ -99,7 +99,7 @@ public: 这道绝佳的面试题我没有用过，如果录友们有面试别人的需求，就把这个套路拿去吧。 -我在[通过一道面试题目，讲一讲递归算法的时间复杂度！](https://programmercarl.com/前序/通过一道面试题目，讲一讲递归算法的时间复杂度！.html)中，以我自己面试别人的真实经历，通过求x的n次方 这么简单的题目，就可以考察候选人对算法性能以及递归的理解深度，录友们可以看看，绝对有收获！ +我在[通过一道面试题目，讲一讲递归算法的时间复杂度！](../前序/递归算法的时间复杂度.md)中，以我自己面试别人的真实经历，通过求x的n次方 这么简单的题目，就可以考察候选人对算法性能以及递归的理解深度，录友们可以看看，绝对有收获！ ## 周四 diff --git a/problems/背包理论基础01背包-1.md b/problems/背包理论基础01背包-1.md index 259a439b..d9b953c0 100644 --- a/problems/背包理论基础01背包-1.md +++ b/problems/背包理论基础01背包-1.md @@ -41,8 +41,6 @@ leetcode上没有纯01背包的问题，都是01背包应用方面的题目， 有n件物品和一个最多能背重量为w 的背包。第i件物品的重量是weight[i]，得到的价值是value[i] 。**每件物品只能用一次**，求解将哪些物品装入背包里物品价值总和最大。 -![动态规划-背包问题](https://code-thinking-1253855093.file.myqcloud.com/pics/20210117175428387.jpg) - 这是标准的背包问题，以至于很多同学看了这个自然就会想到背包，甚至都不知道暴力的解法应该怎么解了。 这样其实是没有从底向上去思考，而是习惯性想到了背包，那么暴力的解法应该是怎么样的呢？ @@ -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数组的数值，如图： diff --git a/problems/背包问题完全背包一维.md b/problems/背包问题完全背包一维.md new file mode 100644 index 00000000..a8e241c3 --- /dev/null +++ b/problems/背包问题完全背包一维.md @@ -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]都是经过计算的就可以了。 + +遍历物品在外层循环，遍历背包容量在内层循环，状态如图： + +![动态规划-完全背包1](https://code-thinking-1253855093.file.myqcloud.com/pics/20210126104529605.jpg) + +遍历背包容量在外层循环，遍历物品在内层循环，状态如图： + +![动态规划-完全背包2](https://code-thinking-1253855093.file.myqcloud.com/pics/20210729234011.png) + +看了这两个图，大家就会理解，完全背包中，两个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 +#include +using namespace std; + +int main() { + int N, bagWeight; + cin >> N >> bagWeight; + vector weight(N, 0); + vector value(N, 0); + for (int i = 0; i < N; i++) { + int w; + int v; + cin >> w >> v; + weight[i] = w; + value[i] = v; + } + + vector 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 +``` + diff --git a/problems/背包问题理论基础完全背包.md b/problems/背包问题理论基础完全背包.md index ae1e9e0b..0cc6e915 100644 --- a/problems/背包问题理论基础完全背包.md +++ b/problems/背包问题理论基础完全背包.md @@ -5,18 +5,11 @@

参与本项目，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们受益！

-# 动态规划：完全背包理论基础 +# 完全背包理论基础-二维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的情况。 + +推导方向如图： + +![](https://code-thinking-1253855093.file.myqcloud.com/pics/20241126112952.png) + +如果放物品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 的价值，推导方向如图： + +![](https://code-thinking-1253855093.file.myqcloud.com/pics/20241126113104.png) + + +（**注意上图和 [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。如图： + +![动态规划-背包问题2](https://code-thinking-1253855093.file.myqcloud.com/pics/2021011010304192.png) + +在看其他情况。 + +状态转移方程 `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数组初始化情况如图所示： + +![](https://code-thinking-1253855093.file.myqcloud.com/pics/20241114161608.png) + +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> dp(weight.size(), vector(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状态图如下： - - -![动态规划-完全背包](https://code-thinking-1253855093.file.myqcloud.com/pics/20210126104510106.jpg) - -相信很多同学看网上的文章，关于完全背包介绍基本就到为止了。 - -**其实还有一个很重要的问题，为什么遍历物品在外层循环，遍历背包容量在内层循环？** - -这个问题很多题解关于这里都是轻描淡写就略过了，大家都默认 遍历物品在外层，遍历背包容量在内层，好像本应该如此一样，那么为什么呢？ - -难道就不能遍历背包容量在外层，遍历物品在内层？ - - -看过这两篇的话： -* [动态规划：关于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]都是经过计算的就可以了。 - -遍历物品在外层循环，遍历背包容量在内层循环，状态如图： - - -![动态规划-完全背包1](https://code-thinking-1253855093.file.myqcloud.com/pics/20210126104529605.jpg) - -遍历背包容量在外层循环，遍历物品在内层循环，状态如图： - -![动态规划-完全背包2](https://code-thinking-1253855093.file.myqcloud.com/pics/20210729234011.png) - -看了这两个图，大家就会理解，完全背包中，两个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 weight = {1, 3, 4}; - vector value = {15, 20, 30}; - int bagWeight = 4; - vector 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 weight = {1, 3, 4}; - vector value = {15, 20, 30}; - int bagWeight = 4; - - vector 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二维数组如图： + +![](https://code-thinking-1253855093.file.myqcloud.com/pics/20241126113752.png) + +因为 物品0 的性价比是最高的，而且 在完全背包中，每一类物品都有无限个，所以有无限个物品0，既然物品0 性价比最高，当然是优先放物品0。 + + +### 本题代码： + + +```CPP #include #include using namespace std; -// 先遍历背包，再遍历物品 -void test_CompletePack(vector weight, vector value, int bagWeight) { +int main() { + int n, bagWeight; + int w, v; + cin >> n >> bagWeight; + vector weight(n); + vector value(n); + for (int i = 0; i < n; i++) { + cin >> weight[i] >> value[i]; + } - vector dp(bagWeight + 1, 0); + vector> dp(n, vector(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 weight; - vector 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 + +

diff --git a/problems/贪心算法理论基础.md b/problems/贪心算法理论基础.md index f042c0ac..6fde2dbb 100644 --- a/problems/贪心算法理论基础.md +++ b/problems/贪心算法理论基础.md @@ -78,7 +78,7 @@ * 求解每一个子问题的最优解 * 将局部最优解堆叠成全局最优解 -这个四步其实过于理论化了，我们平时在做贪心类的题目 很难去按照这四步去思考，真是有点“鸡肋”。 +这个四步其实过于理论化了，我们平时在做贪心类的题目时，如果按照这四步去思考，真是有点“鸡肋”。 做题的时候，只要想清楚 局部最优 是什么，如果推导出全局最优，其实就够了。