动态规划——完全背包问题(公式推导，组合、排列)

news2024/11/25 5:57:15

本文章是对于完全背包一些题型(如题目所示，组合、排列和最小值类型)的总结和理解，依次记录一下，方便回顾与复习。

本文章是基于个人所总结实现的，但在其中遇到了一些疑惑与困难，所以总结一篇与完全背包相关的问题。

题型分为完全背包求组合问题、求排列问题、求最小值问题.

但这一切都是基于完全背包，我们先来介绍一下什么是完全背包。

完全背包问题

二维dp

二维优化

一维dp(滚动数组)

完全背包组合和排列问题

完全背包问题

有N件物品和一个最多能背重量为W的背包。第i件物品的重量是weight[i]，其价值为value[i] 。每件物品都有无限个（也就是可以放入背包多次），求解将哪些物品装入背包里物品价值总和最大。(即如何在有限的空间中尽可能放到整体价值最高).

完全背包和01背包问题唯一不同的地方就是，完全背包每种物品有无限件；而01背包每个物品只有一件。

在这里我认为对你对01背包已经有一定的了解，便不再深入赘述。如果不了解01背包，最好先了解之后再继续阅读。

二维dp

这是 01背包的核心代码

     // 二维数组
    vector<vector<int>> dp(weight.size(), vector<int>(bagweight + 1, 0));

    // 初始化
    for (int j = weight[0]; j <= bagweight; j++) {
        dp[0][j] = value[0];
    }

    // weight数组的大小 就是物品个数
    for(int i = 1; i < weight.size(); 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 - 1][j - weight[i]] + value[i]);//如果大于物品体积，则取 选择当前物品 和 不选择当前物品 的最大值

        }
    }

01背包是每次从中选取一个物品一次，即如果作选取决策的话，当前重量j 只用减去一个weight[i],所以选取后的重量是dp[i-1][j-weight[i]].

注意我下面所说的当前容量，而没有说背包总容量。因为我们是从小到大遍历的背包容量。

而完全背包是可以选取一个物品 多次(k>=0)，即如果作选取决策的话，当前重量j 要减去 k个weight[i],具体多少取决于当前背包容量的大小。所以我们for循环 k从0开始遍历，直至大于当前背包容量停止。而我们也要做出抉择，即选出0-k次中最大的值，如下：

max (dp[i-1][j-weight[i] * k] + value[i]*k)

如果作不选取 决策的话，那么当前的值就不变化，继承上一次的值。即dp[i][j] = dp[i-1][j];

所以现在状态转移方程为：

dp[i][j] = max { max (dp[i-1][j-weight[i] * k] + value[i]*k), dp[i-1][j] }. 其中(1 <= k <= j/weight[i]

代码如下：

    //n代表物品的数量，v代表背包的容量，weight[i]代表第i个物品的体积，value[i]是第i个物品的价值
    vector<vector<int>> dp(N+1,vector<int>(N+1,0));

    //遍历背包物品
    for(int i = 1; i <= n; i++)
    {  
        //遍历背包容量
        for(int j = 1; j <= v; j++)
        {
            //每次选取k件 物品i ，如果容量大于 当前容量j，则停止
            for(int k = 1; k * weight[i] <= j; k++)
            {
                //这句代码相当于max (dp[i-1][j-weight[i] * k] + value[i]*k),而由于k每次在同一行，所以每次和dp[i][j]进行比较。当然这里写max(dp[i-1],...)也没关系，因为最后都是取的 dp[i-1][j-k*weight[i]]+value[i]*k)的最大值。选dp[i-1][j]相当于每次都和第一次比较，而选dp[i][j]相当于每次都和上一次的进行比较，所以dp[i][j]最后一定是最大值
                dp[i][j] = max(dp[i][j],dp[i-1][j-k*weight[i]]+value[i]*k);
            }
            //dp[i][j] = max(dp[i-1][j],dp[i][j]); //这句代码其实不用加，因为上面第一次k一定等于0，
            //所以相当于第一次已经比较了。这里写只是为了更好的显示上面的思路
        }
    }

    return dp[n-1][v];

二维优化

上面我们用了三重for循环，时间复杂度太高了，我们有没有办法把它转化成二维的呢？

记得上面刚说的这个状态转移方程：

一.dp[i][j] = max { max (dp[i-1][j-weight[i] * k] + value[i]*k), dp[i-1][j] }.

其中(1 <= k <= j/weight[i]）

我们看到k的取值最小值为1，那我们不妨先把这一个物品放进去

得到：

二.dp[i][j] = max {max(dp[i-1][j-weight[i]*k -weight[i]]+value[i]*k +value[i]),dp[i-1][j]);

此时k的取值范围为：(0 <= k <= j/weight[i]-1)

对于式子一，我们完全可以可以把式子简化为如下：

三.dp[i][j] = max(dp[i-1][j-weight[i] * k] + value[i]*k),其中

其中(0 <= k <= j/weight[i]）

这是如何做到的呢？我们发现式子一 k的最小值是1，那么当我们让k=0时，发现dp[i-1][j-weight[i] * k] + value[i]*k)就是dp[i-1][j].所以我们完全可以合并这两个！最后只留下一个max，只不过k的最小值由1变成了0.

当j=j-weight[i]时，我们将其带入到式子三：

四.dp[i][j-weight[i]] = max(dp[i-1][j-weight[i] - weight[i]*k] + value[i]*k);其中：

(0 <= k <= j/weight[i]-1)

此时我们再用式子二对比式子四：

二.dp[i][j] = max {max(dp[i-1][j-weight[i]*k -weight[i]]+value[i]*k +value[i]),dp[i-1][j]);

四.dp[i][j-weight[i]] = max(dp[i-1][j- weight[i]*k -weight[i]] + value[i]*k);

可以发现它们是画圈的这一部分完全等价的！范围也是一样的。我们我们把式子四替换到式子二中：

即dp[i][j] = max(dp[i][j-weight[i]]+value[i]，dp[i-1][j]).

这就是我们最终推导出的公式！！！

所以我们再也不需要写那三重循环了，直接二维循环就可以，如下：

    vector<vector<int>> dp(N+1,vector<int>(N+1,0));
    
    //遍历背包物品
    for(int i = 1; i <= n; i++)
    {  
        //遍历背包容量
        for(int j = 0; j <= v; j++)
        {
            //如果选择的话
            if(j >= weight[i])
            dp[i][j] = max(dp[i][j-weight[i]]+value[i],dp[i-1][j]);
            //如果不选择
            else
            dp[i][j] = dp[i-1][j];
        }
    }

一维dp(滚动数组)

和01背包问题问题类似，我们同样可以转化为把二维数组转化为一维数组，因为它们都只依赖于上一行的状态。

因此我们由

dp[i][j] = max(dp[i][j-weight[i]]+value[i],dp[i-1][j]);

可以转化为一维dp数组：

dp[j] = max(dp[j-weight[i]]+value[i],dp[j]);

修改完毕后，代码如下:

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

    for(int i = 1; i <= n; i++)
    {
        for(int j = weight[i]; j <= v; j++)
        {
            dp[j] = max(dp[j-weight[i]]+value[i],dp[j]);
        }
    }
    return dp[v];