背包问题汇总

本系列汇总我对背包问题的学习，其实我在映象笔记里面已经说得很充分了。搬过来吧。

问题描述

先给出常见的背包情形：

01背包（ZeroOnePack）:

有N件物品和一个容量为V的背包。（每种物品均只有一件）第i件物品的费用是c[i]，价值是w[i]。求解将哪些物品装入背包可使价值总和最大。

完全背包(CompletePack):

有N种物品和一个容量为V的背包，每种物品都有无限件可用。第i种物品的费用是c[i]，价值是w[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。

多重背包(MultiplePack):

有N种物品和一个容量为V的背包。第i种物品最多有n[i]件可用，每件费用是c[i]，价值是w[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。

比较三个题目，会发现不同点在于每种背包的数量，01背包是每种只有一件，完全背包是每种无限件，而多重背包是每种有限件。当然，上述背包不可拆分。如果拆分，算出性价比，贪心就好了。

问题分析（01背包）

下面两个帖子说得比较清楚，思路上。
还是对于怎么考虑这个问题我不做太多说明，参看下面的链接。
[利用金矿模型理解背包]

我就直接给问题求解方法：

• 状态定义：dp[i][j]表示把前i件物品放入容量为j的背包中的最大价值
• 初始化：当没有物品放入时，价值为0。所以，dp[0][j] = 0.
• 状态转移:
  
  • $$if \quad j < c[i] \quad then \quad dp[i][j] = dp[i-1][j]$$
  • $$if \quad j \geq c[i] \quad then \quad dp[i][j] = max(dp[i-1][j] , dp[i-1][j-c[i] + w[i])$$

需要注意的问题：

• 初始化的时候不初始化第0列，因为存在容量为0的物品。
• DP的本质是分治，即通过考虑是否将当前物品放入背包去划分子问题，但是这也得等到背包容量起码可以容纳该物品时才可以。所以，转移方程要分两种情况讨论。
• 这种情况，小心就好。入股数组不是从1开始，那么c[i],w[i]均改为c[i-1],w[i-1]

例题1

[hdu-2602]

代码

#include <iostream>
#include <vector>
#include <cstring>
#include <algorithm>
#define MAX 1024
int w[MAX];
int c[MAX];
int dp[MAX][MAX];

int back_pack( int N, int V ){
    std::memset( dp, 0, sizeof(dp) );

    for(int i = 1; i <= N; ++i){
        for( int j = 0; j <= V; ++j ){
            if( j < c[i] )
                dp[i][j] = dp[i-1][j];
            else
                dp[i][j] = std::max( dp[i-1][j], dp[i-1][j-c[i]] + w[i] );
        }
    }
    return dp[N][V];
}

int main( void ){
    int t = 0;
    std::cin >> t;
    while(t--){
        int N,V;
        std::cin >> N >> V;
        for(int i = 1; i <= N; ++i){
            std::cin >> w[i];
        }
        for(int i = 1; i <= N; ++i){
            std::cin >> c[i];
        }

        int ans = back_pack(N, V);
        std::cout << ans << std::endl;

    }
    return 0;
}

空间优化

int dp[MAX];
int back_pack( int N, int V ){
    std::memset( dp, 0, sizeof(dp) );

    for(int i = 1; i <= N; ++i){
        for(int j = V; j >= 0; --j){
            if( j < c[i] )
                dp[j] = dp[j]; // dp[i][j] = dp[i-1][j]保持之前状态不变
            else
                dp[j] = std::max( dp[j], dp[j-c[i]] + w[i] ); // max( dp[i-1][j], dp[i-1][j-c[i]] + w[i] );
        }
    }
    return dp[V];
}

对于上面代码，可以发现，保持状态不变处的代码可以省略。所以，代码进一步优化。

int dp[MAX];
int back_pack( int N, int V ){
    std::memset( dp, 0, sizeof(dp) );

    for(int i = 1; i <= N; ++i){
        for(int j = V; j >= c[i]; --j){
                dp[j] = std::max( dp[j], dp[j-c[i]] + w[i] ); // max( dp[i-1][j], dp[i-1][j-c[i]] + w[i] );
        }
    }
    return dp[V];
}

例题2

题目：[背包问题]
小心上面说的第三点，数组下表不是从1开始的。

代码

class Solution {
public:
    /**
     * @param m: An integer m denotes the size of a backpack
     * @param A: Given n items with size A[i]
     * @return: The maximum size
     */
    int backPack(int m, vector<int> A) {
        // write your code here
        int n = A.size();
        vector<int> dp(m + 1, 0);
        for(int i = 1; i <= n; ++i){
            for(int j = m; j >= A[i-1]; --j){
                dp[j] = max( dp[j], dp[j-A[i-1]] + A[i-1] );
            }
        }
        return dp[m];
    }
};

例题3

题目：[背包问题II]

代码

class Solution {
public:
    /**
     * @param m: An integer m denotes the size of a backpack
     * @param A & V: Given n items with size A[i] and value V[i]
     * @return: The maximum value
     */
    int backPackII(int m, vector<int> A, vector<int> V) {
        // write your code here
        int n = A.size();
        vector<int> dp(m+1, 0);
        for(int i = 1; i <= n; ++i){
            for(int j = m; j >= A[i-1]; --j){
                dp[j] = max(dp[j], dp[j-A[i-1]] + V[i-1]);
            }
        }
        return dp[m];
    }
};

---

后记

背包问题又忘了，所以再次复习，和前面的内容有重合。

题目：[lintcode-背包问题]

几个注意点：

1. 初始化的时候要小心，只初始化第0行。考虑有容量为0的物品
2. 小心下标不一致带来的问题。

class Solution {
public:
    /**
     * @param m: An integer m denotes the size of a backpack
     * @param A: Given n items with size A[i]
     * @return: The maximum size
     */
    int backPack(int m, vector<int> A) {
        // write your code here
        int n = A.size();
        vector<int> w(n+1);
        vector<int> c(n+1);
        for(int i = 0; i < n; ++i){
            w[i+1] = A[i];
            c[i+1] = A[i];
        }


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

        for(int i = 0; i <= m; ++i){
            dp[0][i] = 0;    
        }
        for(int i = 1; i <= n; ++i){
            for(int j = 0; j <= m; ++j){
                if( c[i] <= j )
                    dp[i][j] = max( dp[i-1][j], w[i] + dp[i-1][j-c[i]] );
                else
                    dp[i][j] = dp[i-1][j];
            }
        }
        return dp[n][m];
    }
};

空间优化之后的版本：滚动数组

class Solution {
public:
    /**
     * @param m: An integer m denotes the size of a backpack
     * @param A: Given n items with size A[i]
     * @return: The maximum size
     */
    int backPack(int m, vector<int> A) {
        // write your code here
        int n = A.size();
        vector<int> w(n+1);
        vector<int> c(n+1);
        vector<int> dp(m+1, 0);

        for(int i = 0; i < n; ++i){
            w[i+1] = c[i+1] = A[i];
        }

        for(int i = 1; i <= n; ++i){
            for(int j = m; j >= c[i]; --j){
                dp[j] = max( dp[j], w[i] + dp[j - c[i]] );
            }
        }

        return dp[m];
    }
};

问题分析（完全背包）

和0-1背包类似，只不过每种物品有多种选择。

与01背包相同，完全背包也需要求出NV个状态F[i][j]。但是完全背包求F[i][j]时需要对k分别取0,…，j/C[i]求最大F[i][j]值,耗时为j/C[i]。那么总的时间复
杂度为O(NV∑(j/C[i]))
也就是每次放入物品时，要由于物品有多种选择，因此在容量允许的情况下，对多种选择都要试探。

for(i=1;i<=n;i++)
{
    for(j=0;j<=m;j++)
    {
        for(k=0;k*need[i]<=j;k++)   // 循环条件判断了容量是否充足
            dp[i][j]=max(dp[i][j],dp[i-1][j-k*need[i]]+k*value[i]);
    }
}
printf("%d\n",dp[n][m]);