代码随想录第44天

1.动态规划:完全背包理论基础

完全背包

有N件物品和一个最多能背重量为W的背包。第i件物品的重量是weight[i],得到的价值是value[i] 。每件物品都有无限个(也就是可以放入背包多次),求解将哪些物品装入背包里物品价值总和最大。

完全背包和01背包问题唯一不同的地方就是,每种物品有无限件

背包最大重量为4。

物品为:

重量价值
物品0115
物品1320
物品2430

每件物品可以取无数次,问背包能背的物品最大价值是多少?

在01背包数组中提到过如果先遍历物品在遍历背包容量中,如果遍历的背包容量是正序遍历的话就会出现一件物品被取多次,刚好和这道题题目要求一样,这道题差别就在背包容量的遍历顺序上,其他的和01背包一样(这里用一维去写的)

注(用一维写的):

1.01背包中先后遍历顺序不能改,即只能先遍历物品后遍历背包容量,但是完全背包中可以换,没问题。

首先来复习一下为什么01背包中不能改遍历顺序:

以背包容量为4时举例: 

递推公式是靠遍历的上一个物品中的同背包容量的dp值和特定的不同背包容量(j-weight[i])的dp值进行比较,这和什么遍历顺序无关,就是完全背包也要遵守的,所以当以01背包中先遍历背包容量在遍历物品时,你遍历第一个物品是没问题,但是从2个开始,你上一个物品中特定的不同背包容量(j-weight[i])的dp值还是0也就是不是上一个物品的是初始化的,这样下去你连上一个物品中的同背包容量的dp值都是错的,并且遍历完4后他就不会回来了,这样造成的结果是你只能取一个物品。

 但是对于完全背包,他无论时遍历背包容量还是物品都是正序遍历:

遍历物品在外层循环,遍历背包容量在内层循环,状态如图:

遍历背包容量在外层循环,遍历物品在内层循环,状态如图:

看了这两个图,大家就会理解,完全背包中,两个for循环的先后循序,都不影响计算dp[j]所需要的值(这个值就是下标j之前所对应的dp[j])。

// 先遍历物品,在遍历背包
void test_CompletePack() {
    vector<int> weight = {1, 3, 4};
    vector<int> value = {15, 20, 30};
    int bagWeight = 4;
    vector<int> dp(bagWeight + 1, 0);
    for(int i = 0; i < weight.size(); i++) { // 遍历物品
        for(int j = weight[i]; j <= bagWeight; j++) { // 遍历背包容量
            dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
        }
    }
    cout << dp[bagWeight] << endl;
}
int main() {
    test_CompletePack();
}


// 先遍历背包,再遍历物品
void test_CompletePack() {
    vector<int> weight = {1, 3, 4};
    vector<int> value = {15, 20, 30};
    int bagWeight = 4;

    vector<int> dp(bagWeight + 1, 0);

    for(int 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;
}
int main() {
    test_CompletePack();
}

2.零钱兑换||:

注意他说的是组合数,所以[2,1,2]和[1,2,2]是一样的。

动规五步曲来分析如下:

  1. 确定dp数组以及下标的含义

dp[j]:凑成总金额j的货币组合数为dp[j]

      2.确定递推公式

dp[j] 就是所有的dp[j - coins[i]](考虑coins[i]的情况)相加。

所以递推公式:dp[j] += dp[j - coins[i]];

这个递推公式大家应该不陌生了,我在讲解01背包题目的时候在这篇494. 目标和 (opens new window)中就讲解了,求装满背包有几种方法,公式都是:dp[j] += dp[j - nums[i]];

这里再解释一下:

就拿5来举例(刚开始默认dp[5]是0):

当他遍历到1时,是默认1一定是拿了的,那拿了之后背包只剩下4的容量了,dp[j]:凑成总金额j的货币组合数为dp[j],当只有金额1并且1一定拿了时,在这层的dp[5]比上层的dp[5]多的所有组合中1是里面的最大值,dp[5]+=dp[4]了

 当他遍历到2时,是默认2一定拿了的,那拿了之后背包只剩下3的容量了,当只有金额1和2并且2一定拿了时,在这层的dp[5]比上层的dp[5]多的所有组合中2是里面的最大值,dp[5]+=dp[3]了

 当他遍历到5时,是默认5一定拿了的,那拿了之后背包只剩下0的容量了,当只有金额1,2和5并且5一定拿了时,在这层的dp[5]比上层的dp[5]多的所有组合中5是里面的最大值,dp[5]+=dp[0]了

     3.dp数组如何初始化

首先dp[0]一定要为1,dp[0] = 1是 递归公式的基础。如果dp[0] = 0 的话,后面所有推导出来的值都是0了。

那么 dp[0] = 1 有没有含义,其实既可以说 凑成总金额0的货币组合数为1,也可以说 凑成总金额0的货币组合数为0,好像都没有毛病。

但题目描述中,也没明确说 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循环遍历物品(钱币)呢?

我在动态规划:关于完全背包,你该了解这些! (opens new window)中讲解了完全背包的两个for循环的先后顺序都是可以的。

但本题就不行了!

因为纯完全背包求得装满背包的最大价值是多少,和凑成总和的元素有没有顺序没关系,即:有顺序也行,没有顺序也行!

而本题要求凑成总和的组合数,元素之间明确要求没有顺序。

所以纯完全背包是能凑成总和就行,不用管怎么凑的。

本题是求凑出来的方案个数,且每个方案个数是为组合数。

那么本题,两个for循环的先后顺序可就有说法了。

我们先来看 外层for循环遍历物品(钱币),内层for遍历背包(金钱总额)的情况。

代码如下:

for (int i = 0; i < coins.size(); i++) { // 遍历物品
    for (int j = coins[i]; j <= amount; j++) { // 遍历背包容量
        dp[j] += dp[j - coins[i]];
    }
}

假设:coins[0] = 1,coins[1] = 5。

那么就是先把1加入计算,然后再把5加入计算,得到的方法数量只有{1, 5}这种情况。而不会出现{5, 1}的情况。

所以这种遍历顺序中dp[j]里计算的是组合数!

如果把两个for交换顺序,代码如下:

for (int j = 0; j <= amount; j++) { // 遍历背包容量
    for (int i = 0; i < coins.size(); i++) { // 遍历物品
        if (j - coins[i] >= 0) dp[j] += dp[j - coins[i]];
    }
}

背包容量的每一个值,都是经过 1 和 5 的计算,包含了{1, 5} 和 {5, 1}两种情况。

此时dp[j]里算出来的就是排列数!

//原来代码的结果:

遍历顺序换了之后:
 

 

 

从dp[1][3]开始就错了,至于错的原因:

用j=3举例:
本来dp[3]是初始化的值(0)+dp[1][3-1]+dp[2][3-2](注意这里不是指二维数组,dp前面的括号里的指的是遍历的物品重量)得来的,也就是说每层增加的方法是前面特定的(j - coins[i])背包容量且在同层的情况下(拥有相同金额备选)的dp值,而最终的dp值需要把每层增加的方法全部加起来,但是现在改变遍历顺序后,在算每层(拥有相同金额备选)前面特定的(j - coins[i])背包容量的dp值的时候,这时候前面特定的(j - coins[i])背包容量已经遍历完了所有的物品,这时候是最终的dp值,这样算会导致有重复:

 这上面的每层列举的情况都是每层新增的

     5.举例推导dp数组

输入: amount = 5, coins = [1, 2, 5] ,dp状态图如下:

最后红色框dp[amount]为最终结果。

以上分析完毕,C++代码如下:

class Solution {
public:
    int change(int amount, vector<int>& coins) {
        vector<int> dp(amount + 1, 0);
        dp[0] = 1;
        for (int i = 0; i < coins.size(); i++) { // 遍历物品
            for (int j = coins[i]; j <= amount; j++) { // 遍历背包
                dp[j] += dp[j - coins[i]];
            }
        }
        return dp[amount];
    }
};

 

在求装满背包有几种方案的时候,认清遍历顺序是非常关键的。

如果求组合数就是外层for循环遍历物品,内层for遍历背包

如果求排列数就是外层for遍历背包,内层for循环遍历物品

3.组合总和|V:

动规五部曲分析如下:

  1. 确定dp数组以及下标的含义

dp[i]: 凑成目标正整数为i的排列个数为dp[i]

      2.确定递推公式

dp[i](考虑nums[j])可以由 dp[i - nums[j]](不考虑nums[j]) 推导出来。

因为只要得到nums[j],排列个数dp[i - nums[j]],就是dp[i]的一部分。

这两句话的意思是每层增加的方法(考虑nums[i],因为每层可以遍历的物品不一样,比如第一层可以遍历第一个物品,第二层是物品1和物品2)都是靠最终的dp[i-nums[j]](都说是最终了,就是最后一层了,不用考虑不同层)推导出来的,最终的dp[i]是把每层增加的方法都加起来。

动态规划:494.目标和 (opens new window)和 动态规划:518.零钱兑换II (opens new window)中我们已经讲过了,求装满背包有几种方法,递推公式一般都是dp[i] += dp[i - nums[j]];

本题也一样。

       3.dp数组如何初始化

因为递推公式dp[i] += dp[i - nums[j]]的缘故,dp[0]要初始化为1,这样递归其他dp[i]的时候才会有数值基础。

至于dp[0] = 1 有没有意义呢?

其实没有意义,所以我也不去强行解释它的意义了,因为题目中也说了:给定目标值是正整数! 所以dp[0] = 1是没有意义的,仅仅是为了推导递推公式。

至于非0下标的dp[i]应该初始为多少呢?

初始化为0,这样才不会影响dp[i]累加所有的dp[i - nums[j]]。

     4.确定遍历顺序

个数可以不限使用,说明这是一个完全背包。

得到的集合是排列,说明需要考虑元素之间的顺序。

本题要求的是排列,那么这个for循环嵌套的顺序可以有说法了。

动态规划:518.零钱兑换II (opens new window)中就已经讲过了。

如果求组合数就是外层for循环遍历物品,内层for遍历背包

如果求排列数就是外层for遍历背包,内层for循环遍历物品

如果把遍历nums(物品)放在外循环,遍历target的作为内循环的话,举一个例子:计算dp[4]的时候,结果集只有 {1,3} 这样的集合,不会有{3,1}这样的集合,因为nums遍历放在外层,3只能出现在1后面!

所以本题遍历顺序最终遍历顺序:target(背包)放在外循环,将nums(物品)放在内循环,内循环从前到后遍历

     5.举例来推导dp数组

我们再来用示例中的例子推导一下:

以上分析完毕,C++代码如下:

class Solution {
public:
    int combinationSum4(vector<int>& nums, int target) {
        vector<int> dp(target + 1, 0);
        dp[0] = 1;
        for (int i = 0; i <= target; i++) { // 遍历背包
            for (int j = 0; j < nums.size(); j++) { // 遍历物品
                if (i - nums[j] >= 0 && dp[i] < INT_MAX - dp[i - nums[j]]) {
                    dp[i] += dp[i - nums[j]];
                }
            }
        }
        return dp[target];
    }
};

C++测试用例有两个数相加超过int的数据,所以需要在if里加上dp[i] < INT_MAX - dp[i - num]。

 

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值