leetcode动态规划之背包系列

谜底666

已于 2023-10-06 11:27:45 修改

阅读量539

点赞数

分类专栏： # leetcode动态规划系列文章标签：动态规划 leetcode 算法

于 2023-04-20 08:44:27 首次发布

本文链接：https://blog.csdn.net/midi666/article/details/130257570

版权

leetcode动态规划系列专栏收录该内容

43 篇文章 0 订阅

订阅专栏

01背包基础
先放两个01背包基础的讲解：
二维数组法
 一维数组法
01背包问题的主要核心是，每个物品只能使用一次（完全背包是可以使用多次），在这里要背下来如下公式：
二维数组法：两个for循环可以互换，且不需要逆序遍历
一维数组法：必须是外层循环遍历物品，内存循环遍历背包容量且是逆序。

01背包的几道题目：

纯 0 - 1 背包：是求给定背包容量装满背包的最大价值是多少。
分割等和子集：求给定背包容量，能不能装满这个背包。
目标和：求给定背包容量，装满背包有多少种方法。
最后一块石头的重量 II ：求给定背包容量，尽可能装，最多能装多少。
一和零：求给定背包容量，装满背包最多有多少个物品。

416 分割等和子集

题目：给个数组nums，判断能否分割成两个和相等的子集，返回true or false
给定背包容量target，能不能装满这个背包

解析：
先把给定数组的和求出来，对2取模等于1的直接返回法false，因为必然不可能得出来两个相等的子集；再除以2求出target；需要理解下什么是target，目前看来先是最后要用于比较的结果，其次对于背包问题来说，是背包的大小（容量）

1.dp数组确定及其含义：
dp[j]表示在背包的容量为j的时候，放入物品后，背包最大重量为dp[j]。注意这里叫dp[j]主要是为了和二维数组压缩到一维的对齐，其实只是一个局部变量，定义叫什么都行

2.确定递推公式：
dp[j] = max(dp[j], dp[j-nums[i]] + nums[i])
物品的重量是nums[i]，价值也是nums[i]

3.初始化为0

4.遍历顺序：物品外层，背包内层且倒序

func canPartition(nums []int) bool {
    n := len(nums)
    sum := 0
    for _, num := range nums {
        sum += num
    }
    if sum % 2 == 1 { // 必须要有，过掉一部分测试用例
        return false
    }

    target := sum / 2
    dp := make([]int, 20001) // 示例中给的最大值的乘积
    for i := 0; i < n; i++ { // 因为遍历的是物品，所以都是从下标0第一个物品开始
        for j := target; j >= nums[i]; j-- { // j遍历的是背包，背包的容量一定得大于这次要放的这个物品的重量
            dp[j] = max(dp[j], dp[j-nums[i]]+nums[i])
        }
    }
    return dp[target] == target
}

func max(a, b int) int {
    if a > b {
        return a
    }
    return b
}

494 目标和
题目：给定数组nums和target，在每个数字前放“+”或“-”，最后等于target的有多少种方法
给定背包容量，求装满背包有多少种方法

解析：
得先有点数学推导：所有的加号子集和为sum( p)，减号子集和为sum(q)，则有sum( p) - sum(q) = target（注，这里本身不带符号，比如sum( p) = 5, sum(q) = 3, target = 2）;
sum( p) + sum(q) = sum
则有：sum( p) + sum(q) + (sum( p) - sum(q) ) = sum( p) + sum(q) + target
左边为2 * sum( p), 右边为sum + target
有sum( p) = (sum + target) / 2（求出来的就是背包大小）
因为要除以2后成立，一定得是偶数

1.dp数组确定及其含义：
dp[j]表示在背包的容量为j的时候，填满背包有dp[j]种方法

2.确定递推公式：
dp[j] += dp[j - nums[i]] (求组合类的问题一般都是这个公式)

3.初始化为dp[0] = 1，不然后面都是0了

4.遍历顺序：物品外层，背包内层且倒序

func findTargetSumWays(nums []int, target int) int {
    n := len(nums)
    sum := 0
    for _, num := range nums {
        sum += num
    }
    if abs(target) > sum {
        return 0
    }
    if (sum + target) % 2 == 1 {
        return 0
    }
    bag := (sum + target) / 2 // 背包容量
    dp := make([]int, 20001) // dp数组的定义：在背包容量为j的时候，有dp[j]中方法可以填满背包
    dp[0] = 1
    for i := 0; i < n; i++ { // 遍历物品
        for j := bag; j >= nums[i]; j-- { // 遍历背包
            dp[j] += dp[j - nums[i]]
        }
    }
    return dp[bag]
}

func abs(target int) int {
    return int(math.Abs(float64(target)))
}

1049 最后一块石头的重量
题目：给定数组nums，nums[i]代表第 i 块石头的重量，要求分成重量接近的两堆，求剩余的重量
给定背包容量，尽可能装，最多能装多少

1.dp数组及其含义
dp[j]表示容量为j的背包，最多可以背最大重量为dp[j]；

2.递推公式
dp[j] = max(dp[j], dp[j - stones[i]] + stones[i])

3.初始化
为0

4.遍历顺序：物品外层，背包内层且倒序

func lastStoneWeightII(stones []int) int {
    n := len(stones)
    sum := 0
    for _, val := range stones {
        sum += val
    }
    bag := sum / 2
    dp := make([]int, 3001)
    for i := 0; i < n; i++ {
        for j := bag; j >= stones[i]; j-- {
            dp[j] = max(dp[j], dp[j-stones[i]] + stones[i]) // max里面的那个dp[j]，其实是二维dp数组压缩下来的
        }
    }
    return sum - dp[bag] - dp[bag]
}

func max(a, b int) int {
    if a > b {
        return a
    }
    return b
}

474 一和零
题目：给你一个二进制字符串数组 strs 和两个整数 m 和 n 。请你找出并返回 strs 的最大子集的长度，该子集中最多有 m 个 0 和 n 个 1 。
求给定背包容量，装满背包最多有多少个物品。

解析：首先这道题还是一个01背包，且是一个二维数组的，但是还对应的是一维数组的解法；

1.确定dp数组以及下标的含义
dp[i][j]：最多有i个0和j个1的strs，其最大子集的大小（长度）为dp[i][j]

2.确定递推公式
dp[i][j] 可以由前一个strs里的字符串推导出来，strs里的字符串有zeroNum个0，oneNum个1。
dp[i][j] 就可以是 dp[i - zeroNum][j - oneNum] + 1，这个1是指字符串本身的个数（长度、大小）+1（类似于物品的价值）
dp[i][j] = max(dp[i][j], dp[i - zeroNum][j - oneNum] + 1);

回想一下01背包的递推公式：dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
对比一下就会发现，字符串的zeroNum和oneNum相当于物品的重量（weight[i]），字符串本身的个数相当于物品的价值（value[i]）。

3.初始化为0

func findMaxForm(strs []string, m int, n int) int {
    dp := make([][]int, m+1)
    for i := 0; i <= m; i++ {
        dp[i] = make([]int, n+1)
    }
    for i := 0; i < len(strs); i++ { // 遍历物品
        zeroNum, oneNum := 0, 0 // 每进来就初始化一次
        // 根据题意，给的是一个字符串数组，因此要求每个下标的字符串
        for _, v := range strs[i] {
            if v == '0' {
                zeroNum++
            }
        }
        oneNum = len(strs[i]) - zeroNum
        // 分别遍历0的背包容量和1的背包容量
        for j := m; j >= zeroNum; j-- {
            for k := n; k >= oneNum; k-- {
                dp[j][k] = max(dp[j][k], dp[j-zeroNum][k-oneNum] + 1)
            }
        }
    }
    return dp[m][n]
}
func max(a, b int) int {
    if a > b {
        return a
    }
    return b
}

完全背包的几道题目：
首先完全背包是指每个物品可以使用无限次，他的公式可以暂时记为：

求组合数：外层for循环遍历物品，内层for遍历背包。（零钱兑换II）
求排列数：外层for遍历背包，内层for循环遍历物品。（组合综合IV、爬楼梯、单次拆分）
求最小数：外层for遍历背包，内层for循环遍历物品。（零钱兑换、完全平方数）

518 零钱兑换II

题目：整数数组 coins 表示不同面额的硬币，另给一个整数 amount 表示总金额。计算并返回可以凑成总金额的硬币组合数
求组合数
解析：注意求的是组合数，不是排列，组合上面的已经有过大致的递推公式了。
1.确定dp数组以及下标的含义
dp[j]：凑成总金额j的货币组合数为dp[j]
2.确定递推公式
dp[j] += dp[j - coins[i]]; （求组合，不是求排列）
3.dp数组如何初始化
dp[0] = 1 和之前的题目一样，不然永远是0了

func change(amount int, coins []int) int {
    n := len(coins)
    dp := make([]int, amount+1)  // dp[j]为凑到金额为j，有dp[j]中方法
    dp[0] = 1
    for i := 0; i < n; i++ { // 物品
        for j := coins[i]; j <= amount; j++ {
            dp[j] += dp[j-coins[i]] // 求组合的公式
        } 
    }   
    return dp[amount]
}
func max(a, b int) int {
    if a > b {
        return a
    }
    return b
}

377 组合总和IV

题目：给你一个由不同整数组成的数组 nums ，和一个目标整数 target 。请你从 nums 中找出并返回总和为 target 的元素组合的个数。
求排列数
解析：根据示例，虽然这道题说的是求组合，其实是求排列，求排列的话，根据公式，外循环遍历背包，内循环遍历物品

func combinationSum4(nums []int, target int) int {
    n := len(nums)
    dp := make([]int, target+1)
    dp[0] = 1
    for i := 0; i <= target; i++ { // 求排列，先遍历背包，再遍历物品
        for j := 0; j < n; j++ { // 遍历物品，正序
            if i >= nums[j] { // 这个判断其实是相当于，i是背包容量，要大于等于本次要放的物品的重量
                dp[i] += dp[i-nums[j]]
            }
        }
    }
    return dp[target]
}

70 爬楼梯

题目：假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
求排列数
解析：这道题n死背包容量，1和2是物品，可能多次使用，根据示例，是全排列，那其实和上一道题是一样的

func climbStairs(n int) int {
    dp := make([]int, n+1)
    dp[0] = 1
    for i := 0; i <= n; i++ { // 背包
        for j := 1; j <= 2; j++ { // 物品，只有1和2
            if i >= j {
                dp[i] += dp[i-j]
            }
        }
    }
    return dp[n]
}

322 零钱兑换

题目：给你一个整数数组 coins ，表示不同面额的硬币；以及一个整数 amount ，表示总金额。
计算并返回可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1 。
求最小数
解析：上一道零钱兑换求的是有多少种兑换方法（组合），本题求的是最少硬币个数。根据讲解完全背包的时候，先遍历背包还是先遍历物品都是可以的，~~下面这个是先遍历物品的，详细题解中是先遍历背包的~~ ，干脆还是记先遍历背包的代码把，看着这几道题都是先遍历背包的，求排列是先遍历背包，再先遍历物品或背包都行的情况下，完全背包的题也记先遍历背包吧

func coinChange(coins []int, amount int) int {
    dp := make([]int, amount+1)
    dp[0] = 0 // dp数组表示凑成总金额为0需要的最小硬币数量一定是0
    for i := 1; i < amount+1; i++ {
        dp[i] = math.MaxInt32 //因为要求最小数量，所以全部初始化为最大值
    }
    for i := 1; i <= amount; i++ { //遍历背包,0 没啥用不需要遍历了
        for j := 0; j < len(coins); j++ { //遍历物品
            if i - coins[j] >= 0 { // 注意是谁和谁比较大小，是背包容量大于本次物品的价值
                dp[i] = min(dp[i], dp[i-coins[j]]+1) // 哪个下标是背包，就是dp哪个
            }
        }
    }
    if dp[amount] == math.MaxInt32 {
        return -1
    }
    return dp[amount]
}

func min(a, b int) int {
    if a > b {
        return b
    }
    return a
}

279 完全平方数

题目：给你一个整数 n ，返回和为 n 的完全平方数的最少数量
求最小数
解析：这题其实就是在上一题的基础上，改一下符合完全平方的条件就行

func numSquares(n int) int {
    dp := make([]int, n+1) // 和为j的最少数量为dp[j]
    dp[0] = 0
    for i := 1; i <= n; i++ { // 初始化
        dp[i] = math.MaxInt32
    }
    for i := 1; i <= n; i++ { // 背包
        for j := 1; j <= i; j++ { // 物品，注意下物品的个数
            if i >= j*j {
                dp[i] = min(dp[i], dp[i-j*j]+1)
            }
        }
    }
    return dp[n]
}

func min(a, b int) int {
    if a < b {
        return a
    }
    return b
}

139 单词拆分

题目：给你一个字符串 s 和一个字符串列表 wordDict 作为字典。请你判断是否可以利用字典中出现的单词拼接出 s 。字典中的单词可以无限使用
求排列数
解析：首先要明白这肯定是完全背包问题，另外s是背包，wordDict是物品；
1.确认dp数组及其含义
dp[i]: 字符串长度为i的话，dp[i]为true，表示可以拆分为一个或多个在字典中出现的单词（注意这里的定义比较奇怪，定义的是字符串的长度是0，那么dp[0]代表的就是空串，遍历的时候要小于等于n，是有n的）
2.确定递推公式
在 j < i 的情况下，如果确定dp[j] 是true，且 [j, i] 这个区间的子串出现在字典里，那么dp[i]一定是true。
3.初始化
dp[0] = true,因为是根据它推出来的，不然后面的都成了false了
4.遍历顺序
排列问题，外层背包，内层物品

func wordBreak(s string, wordDict []string) bool {
    wordDictMap := make(map[string]bool)
    for _, val := range wordDict {
        wordDictMap[val] = true
    }
    // s是背包，wordDict是物品
    n := len(s)
    dp := make([]bool, n+1)
    dp[0] = true
    for i := 1; i <= n; i++ { // 遍历背包(为什么要有等于)
        for j := 0; j <= i; j++ { // 遍历物品，需要小于等于背包容量
            if dp[j] && wordDictMap[s[j:i]] {
                dp[i] = true
            }
        }
    }   
    return dp[n]
}

谜底666

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
leetcode动态规划之背包系列

再除以2求出target；得先有点数学推导：所有的加号子集和为sum§，减号子集和为sum(q)，则有sum§ - sum(q) = target（注，这里本身不带符号，比如sum§ = 5, sum(q) = 3, target = 2）;则有：sum§ + sum(q) + (sum§ - sum(q) ) = sum§ + sum(q) + target。dp[j]表示在背包的容量为j的时候，放入物品后，背包最大重量为dp[j]dp[j]表示在背包的容量为j的时候，填满背包有dp[j]种方法。
复制链接

扫一扫