背包问题详解：01背包、完全背包、多重背包

蔚落 2022-09-30 00:54 404阅读 0赞

参考链接：

  1. http://www.cnblogs.com/fengty90/p/3768845.html
  2. http://blog.csdn.net/mu399/article/details/7722810
  3. http://blog.csdn.net/xiaowei_cqu/article/details/8191808
  4. http://blog.csdn.net/insistgogo/article/details/11176693

背包问题是动态规划算法的一个典型实例，首先介绍动态规划算法：

动态规划：

  1. 基本思想：

动态规划算法通常用于求解具有某种最优性质的问题。在这类问题中， 可能会有很多可行解。没一个解都对应于一个值，我们希望找到具有最优值的解。胎动规划算法与分治法类似，其基本思想也是将待求解问题分解为若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。与分治法不同的是，适用于动态规划算法求解的问题，经分解得到的子问题往往不是互相独立的。若用分治法来解这类问题，则分解得到的子问题数目太多，有些子问题被重复计算很多次。如果我们能保存已解决子问题的答案，而在需要时再找出已求得的答案，这样就可以避免大量的重复计算，节省时间。我们可以用一个表来记录所有已解决的子问题的答案。不管该子问题以后是否被用到，只要它被计算过，就将其结果填入表中。这就是动态规划算法的基本思路。具体的动态规划算法多种多样，但它们具有相同的填表格式。

与分治法最大的差别是：适用于动态规划求解的问题，经分解后得到的子问题往往不是互相独立的（即下一个子阶段的求解是建立在上一个子阶段的解的基础上，进行进一步的求解）

  1. 应用场景：

适用于动态规划的问题必须满足最优化原理、无后效性和重叠性。

(1) 最优化原理（最优子结构性质）：一个最优化策略具有这样的性质，不论过去状态和决策如何，对前面的决策所形成的状态而言，余下的决策必须构成最优策略。简而言之，一个最优化策略的子策略总是最优的。一个问题满足最优化原理又称其具有最优子结构性质。

(2) 无后效性：将各阶段按照一定的次序排列好之后，对于某个给定的阶段状态，它以前各阶段的状态无法直接影响它未来的决策，而只能通过当前的这个状态。换句话说，每个状态都是过去历史的一个完整总结。这就是无后向性，又称无后效性。

(3) 子问题的重叠性：动态规划将原来具有指数级时间复杂度的搜索算法改进成了具有多项式时间复杂度的算法。其中的关键在于解决冗余，这就是动态规划算法的根本目的。动态规划实质上是一种以空间换时间的技术，它在实现的过程中，不得不存储产生过程中的各种状态，所以它的空间复杂度要大于其他算法。

01背包问题：

01背包问题描述：有编号分别为a,b,c,d,e的五件物品，它们的重量分别是2,2,6,5,4，它们的价值分别是6,3,5,4,6，每件物品数量只有一个，现在给你个承重为10的背包，如何让背包里装入的物品具有最大的价值总和？

动态规划的基本思路：将该问题转换成子问题，考虑五件物品在给定承重 C 的背包下最大价值为原问题，如下表所示，即为考虑abcde，C = 10时的最大价值，假设为f[5][10]，原问题的解可以分解为两种情况，第一种情况是不考虑放入a只考虑放入bcde承重为C时的最大价值f[4][C],第二种情况是考虑放入a时的最大价值，即value[a]+f[4][10-weight[a]]。 原问题的解f[5][10]取上述两种情况中的最大值，即f[5][10] = max{f[4][10], (f[4][10-weight[a]+value[a]))}。 由此可以看出里面涉及到需要计算f[4][10]和f[4][10-weight[a]]即f[4][4]等子问题。 以此类推，自顶向下的分析可以看出原问题需要子问题的解，我们需要先计算出子问题的解，自底向上求解。求解方式如下表所示，顺序是自底向上、从左往右，或者从左往右、自底向上都可以。注意此问题中的abcde可以包含相同的物件，它们之间的顺序也可以是任意的，不影响最终的结果。




































































































name weight value 0 1 2 3 4 5 6 7 8 9 10
a 2 6 0 0 6 6 9 9 12 12 15 15 15
b 2 3 0 0 3 3 6 6 9 9 9 10 11
c 6 5 0 0 0 0 6 6 6 6 6 10 11
d 5 4 0 0 0 0 6 6 6 6 6 10 10
e 4 6 0 0 0 0 6 6 6 6 6 6 6

按上述描述的递推公式计算时，我们需要初始值，f[i][0]=0(1<=i<=5), f[1][j]=(j < weight[e])?0:value[e],(1<=j<=10)。代码如下：

  1. #include <iostream>
  2. using namespace std;
  5. int knapsack(int *W, int *V, int *res, int n, int C)
  6. {
  7.     int value = 0;
  8.     int **f = new int*[n];
  9.     for(int i = 0; i < n; i++)
  10.     {
  11.         f[i] = new int[C+1];
  12.     }
  14.     for(int i = 0; i < n; i++)
  15.         for(int j = 0; j <= C;j++)
  16.             f[i][j] = 0;
  18.     for(int i = 0; i < n; i++)
  19.     {
  20.         f[i][0] = 0;
  21.     }
  22.     for(int i = 1; i <= C; i++)
  23.     {
  24.         f[0][i] = (i < W[0])?0:V[0];
  25.     }
  26.     for(int i = 1; i < n; i++)
  27.     {
  28.         for(int y = 1; y <= C; y++)
  29.         {
  30.             if(y >= W[i])
  31.             {
  32.                 f[i][y] = (f[i-1][y] > (f[i-1][y-W[i]] + V[i]))?f[i-1][y]:(f[i-1][y-W[i]] + V[i]);
  33.             } else {
  34.                 f[i][y] = f[i-1][y];
  35.             }
  36.         }
  37.     }
  39.     for(int i = 0; i < n; i++)
  40.     {
  41.         for(int j = 0; j < C+1;j++)
  42.            cout << f[i][j] << " ";
  43.         cout << endl;
  44.     }
  46.     value = f[n-1][C];
  47.     int j = n-1;
  48.     int y = C;
  49.     while(j)
  50.     {
  51.         if(f[j][y] == (f[j-1][y-W[j]] + V[j]))
  52.         {
  53.             res[j] = 1;
  54.             y = y - W[j];
  55.         }
  56.         j--;
  57.     }
  58.     if(f[0][y])
  59.     {
  60.         res[0] = 1;
  61.     }
  63.     for(int i = 0; i < n;i++)
  64.     {
  65.         delete f[i];
  66.         f[i] = 0;
  67.     }
  68.     delete [] f;
  69.     f = 0;
  70.     return value;
  71. }
  73. void test1()
  74. {
  75.     int n, C;
  76.     while(cin >> n >> C)
  77.     {
  78.         int *W = new int[n];
  79.         int *V = new int[n];
  80.         int *res = new int[n];
  81.         for(int i = 0; i < n; i++)
  82.         {
  83.             res[i] = 0;
  84.         }
  85.         int w = 0, v = 0, i = 0;
  86.         while(i < n)
  87.         {
  88.             cin >> w >> v;
  89.             W[i] = w;
  90.             V[i] = v;
  91.             i++;
  92.         }
  93.         int value = knapsack(W, V, res, n, C);
  94.         cout << value << endl;
  95.         for(int i = 0; i < n; i++)
  96.             cout << res[i] << " ";
  97.         cout << endl;
  98.         delete W;
  99.         delete V;
  100.         delete res;
  101.     }
  102. }
  104. int main()
  105. {
  106.     test1();
  107.     return 0;
  108. }

输入示例：

  1. 5 10      //5种物品，背包承重为10
  2. 2 6       //第一种物品，重量为2，价值为1，数目1个
  3. 2 3
  4. 6 5
  5. 5 4
  6. 4 6

输出示例：

  1. 0 0 6 6 6 6 6 6 6 6 6         //只放入第一种物品，承重为0-10的最优值结果
  2. 0 0 6 6 9 9 9 9 9 9 9         //放入第一种和第二种物品，承重为0-10的最优值结果
  3. 0 0 6 6 9 9 9 9 11 11 14      //放入第一种、第二种和第三种物品，承重为0-10的最优值结果
  4. 0 0 6 6 9 9 9 10 11 13 14     //放入前四种物品，承重为0-10的最优值结果
  5. 0 0 6 6 9 9 12 12 15 15 15    //放入五种物品，承重为0-10的最优值结果
  6. 15              //原问题的解，放入五种物品，承重为10的最优值结果
  7. 1 1 0 0 1       //背包中放入第一种、第二种、第五种物品时价值最高，1*6+1*3+0*5+0*4+1*6 = 15

完全背包问题：

完全背包问题描述：有编号分别为a,b,c,d的四件物品，它们的重量分别是2,3,4,7，它们的价值分别是1,3,5,9，每件物品数量无限个，现在给你个承重为10的背包，如何让背包里装入的物品具有最大的价值总和？

完全背包问题与01背包问题的区别在于每一件物品的数量都有无限个，而01背包每件物品数量只有一个。

问题解法其实和01背包问题一样，只是初始化的值和递推公式需要稍微变化一下。初始化时，当只考虑一件物品a时，f[1][j] = j/weight[a]。 递推公式计算时，f[i][y] = max{f[i-1][y], (f[i][y-weight[i]]+value[i])}，注意这里当考虑放入一个物品 i 时应当考虑还可能继续放入 i，因此这里是f[i][y-weight[i]]+value[i], 而不是f[i-1][y-weight[i]]+value[i]。




















































































name weight value 0 1 2 3 4 5 6 7 8 9 10
d 7 9 0 0 1 3 5 5 6 9 10 10 12
c 4 5 0 0 1 3 5 5 6 8 10 10 11
b 3 3 0 0 1 3 3 4 6 6 7 9 9
a 2 1 0 0 1 1 2 2 3 3 4 4 5

代码如下：

  1. #include <iostream>
  2. using namespace std;
  5. int knapsack_complete(int *W, int *V, int *res, int n, int C)
  6. {
  7.     int value = 0;
  8.     int **f = new int*[n];
  9.     for(int i = 0; i < n; i++)
  10.     {
  11.         f[i] = new int[C+1];
  12.     }
  14.     for(int i = 0; i < n; i++)
  15.     {
  16.         for(int j = 0; j < C+1; j++)
  17.             f[i][j] = 0;
  18.     }
  19.     for(int y = 1; y < C+1; y++)
  20.     {
  21.         f[0][y] = (y < W[0])?0:((y/W[0])*V[0]);
  22.     }
  24.     for(int i = 1; i < n; i++)
  25.     {
  26.         for(int y = 1; y < C+1; y++)
  27.         {
  28.             if(y < W[i])
  29.             {
  30.                 f[i][y] = f[i-1][y];
  31.             } else {
  32.                 f[i][y] = (f[i-1][y] > (f[i][y-W[i]]+V[i]))?f[i-1][y]:(f[i][y-W[i]]+V[i]);
  33.             }
  34.         }
  35.     }
  37.     for(int i = 0; i < n; i++)
  38.     {
  39.         for(int j = 0; j < C+1; j++)
  40.             cout << f[i][j] << " ";
  41.         cout << endl;
  42.     }
  44.     value = f[n-1][C];
  45.     int j = n-1;
  46.     int y = C;
  47.     while(j)
  48.     {
  49.         if(f[j][y] == (f[j][y-W[j]]+V[j]))
  50.         {
  51.             res[j]++;
  52.             y = y - W[j];
  53.         }
  54.         j--;
  55.     }
  56.     res[0] = f[0][y]/V[0];
  58.     for(int i = 0; i < n; i++)
  59.     {
  60.         delete f[i];
  61.         f[i] = 0;
  62.     }
  63.     delete [] f;
  64.     f = 0;
  65.     return value;
  66. }
  67. void test1()
  68. {
  69.     int n, C;
  70.     while(cin >> n >> C)
  71.     {
  72.         int *W = new int[n];
  73.         int *V = new int[n];
  74.         int *res = new int[n];
  75.         for(int i = 0; i < n; i++)
  76.         {
  77.             res[i] = 0;
  78.         }
  79.         int i = 0, w, v;
  80.         while(i < n)
  81.         {
  82.             cin >> w >> v;
  83.             W[i] = w;
  84.             V[i] = v;
  85.             i++;
  86.         }
  87.         int value = knapsack_complete(W, V, res, n, C);
  88.         cout << value << endl;
  89.         for(int i = 0; i < n; i++)
  90.             cout << res[i] << " ";
  91.         cout << endl;
  92.         delete W; W = 0;
  93.         delete V; V = 0;
  94.         delete res; res = 0;
  95.     }
  96. }
  98. int main()
  99. {
  100.     test1();
  101.     return 0;
  102. }

输入示例：

  1. 4 10         //4种物品，背包承重为10
  2. 2 1          //第一种物品，重量为2，价值为1，数目不限
  3. 3 3
  4. 4 5
  5. 7 9

输出示例：

  1. 0 0 1 1 2 2 3 3 4 4 5        //只放入第一种物品，承重为0-10的最优值结果
  2. 0 0 1 3 3 4 6 6 7 9 9        //放入第一种和第二种物品，承重为0-10的最优值结果
  3. 0 0 1 3 5 5 6 8 10 10 11     //放入第一种、第二种和第三种物品，承重为0-10的最优值结果
  4. 0 0 1 3 5 5 6 9 10 10 12     //放入四种物品，承重为0-10的最优值结果
  5. 12           //原问题的解，放入四种物品，承重为10的最优值结果
  6. 0 1 0 1      //第一种物品放0个，第二种物品放1个，第三种物品放0个，第四种物品放1个，0*1+1*3+0*5+1*9 = 12

多重背包问题：

多重背包问题描述：有编号分别为a,b,c的三件物品，它们的重量分别是1，2，2，它们的价值分别是6，10，20，他们的数目分别是10，5，2，现在给你个承重为 8 的背包，如何让背包里装入的物品具有最大的价值总和？

多重背包和01背包、完全背包的区别：多重背包中每个物品的个数都是给定的，可能不是一个，绝对不是无限个。

有两种解法，解题思路：

  1. 作为一个新问题考虑，由于每个物品多了数目限制，因此初始化和递推公式都需要更改一下。初始化时，只考虑一件物品a时，f[1][j] = min{num[1], j/weight[1]}。 计算考虑i件物品承重限制为y时最大价值f[i][y]时，递推公式考虑两种情况，要么第 i 件物品一件也不放，就是f[i-1][y], 要么第 i 件物品放 k 件，其中 1 <= k <= (y/weight[i])，考虑这一共 k+1 种情况取其中的最大价值即为f[i][y]的值，即f[i][y] = max{f[i-1][y], (f[i-1][y-k*weight[i]]+k*value[i])}。 这里为什么不能像完全背包一样直接考虑f[i][y-weight[i]]+value[i]呢？因为这样不容易判断第 i 件物品的个数是否超过限制数量 num[i]。































































name weight value num 0 1 2 3 4 5 6 7 8
c 2 20 2 0 6 20 26 40 46 52 58 64
b 2 10 5 0 6 12 18 24 30 36 42 48
a 1 6 10 0 6 12 18 24 30 36 42 48

代码如下：

  1. #include <iostream>
  2. using namespace std;
  5. int knapsack_limitnum(int *W, int *V, int *N, int *res, int n, int C)
  6. {
  7.     int value = 0;
  8.     int **f = new int*[n];
  9.     for(int i = 0; i < n; i++)
  10.     {
  11.         f[i] = new int[C+1];
  12.     }
  13.     for(int i = 0; i < n; i++)
  14.         for(int j = 0; j < C+1; j++)
  15.             f[i][j] = 0;
  17.     for(int y = 1; y < C+1; y++)
  18.     {
  19.         int count = min(N[0], y/W[0]);
  20.         f[0][y] = (y < W[0])?0:(count * V[0]);
  21.     }
  23.     for(int i = 1; i < n; i++)
  24.     {
  25.         for(int y = 1; y < C+1; y++)
  26.         {
  27.             if(y < W[i])
  28.             {
  29.                 f[i][y] = f[i-1][y];
  30.             } else {
  31.                 int count = min(N[i], y/W[i]);
  32.                 f[i][y] = f[i-1][y];
  33.                 for(int k = 1; k <= count; k++)
  34.                 {
  35.                     int temp = f[i-1][y-W[i]*k] + k*V[i];
  36.                     if(temp >= f[i][y])
  37.                         f[i][y] = temp;
  38.                 }
  39.             }
  40.         }
  41.     }
  43.     for(int i = 0; i < n; i++)
  44.     {
  45.         for(int y = 0; y < C+1; y++)
  46.             cout << f[i][y] << " ";
  47.         cout << endl;
  48.     }
  50.     value = f[n-1][C];
  51.     int j = n-1;
  52.     int y = C;
  53.     while(j)
  54.     {
  55.         int count = min(N[j], y/W[j]);
  56.         for(int k = count; k > 0; k--)
  57.         {
  58.             if(f[j][y] == (f[j-1][y-W[j]*k]+k*V[j]))
  59.             {
  60.                 res[j] = k;
  61.                 y = y - k*W[j];
  62.                 break;
  63.             }
  64.         }
  65.         j--;
  66.     }
  67.     res[0] = f[0][y]/V[0];
  70.     for(int i = 0;i < n; i++)
  71.     {
  72.         delete f[i];
  73.         f[i] = 0;
  74.     }
  75.     delete [] f;
  76.     f = 0;
  77.     return value;
  78. }
  80. void test1()
  81. {
  82.     int n, C;
  83.     while(cin >> n >> C)
  84.     {
  85.         int *W = new int[n];
  86.         int *V = new int[n];
  87.         int *N = new int[n];
  88.         int *res = new int[n];
  89.         for(int i =0; i < n; i++)
  90.             res[i] = 0;
  91.         int w, v, n1, i = 0;
  92.         while(i < n)
  93.         {
  94.             cin >> w >> v >> n1;
  95.             W[i] = w;
  96.             V[i] = v;
  97.             N[i] = n1;
  98.             i++;
  99.         }
  100.         int value = knapsack_limitnum(W, V, N, res, n, C);
  101.         cout << value << endl;
  102.         for(int i = 0; i < n; i++)
  103.             cout << res[i] << " ";
  104.         cout << endl;
  105.         delete res; res = 0;
  106.         delete N; N = 0;
  107.         delete V; V = 0;
  108.         delete W; W = 0;
  109.     }
  110. }
  113. int main()
  114. {
  115.     test1();
  116.     return 0;
  117. }

输入示例：

  1. 3 8           //3件物品，背包承重最大为8
  2. 1 6 10        //第一件物品， 重量为1，价值为6， 数目为10
  3. 2 10 5
  4. 2 20 2

输出结果：

  1. 0 6 12 18 24 30 36 42 48    //放入第一种物品，承重限制为0-8的最优值结果
  2. 0 6 12 18 24 30 36 42 48    //放入第一种和第二种物品，承重限制为0-8的最优值结果
  3. 0 6 20 26 40 46 52 58 64    //放入三种物品，承重限制为0-8的最优值结果
  4. 64            //原问题的解，在背包承重为8中放3种物品最大价值为64
  5. 4 0 2         //最优解对应第一件物品放4个，第二件物品放0个，第三件物品放2个，即4*6+0*10+2*20 = 64
  1. 多重背包的第二种解法，由01背包的分析可知，01背包中允许放入的物品有重复，即01背包中如果考虑要放入的物品的重量和价格相同，不影响最终的结果，因为我们可以考虑把多重背包问题中限制数目的物品拆分成单独的一件件物品，作为01背包问题考虑。问题解法和01背包一致，这里不再列举出动态规划的表格了。

代码：

  1. #include <iostream>
  2. #include <vector>
  3. using namespace std;
  6. int knapsack_limitnum(vector<int> &W, vector<int> &V, vector<int> &res, int C)
  7. {
  8.     int value = 0;
  9.     int **f = new int*[W.size()];
  10.     for(int i = 0; i < W.size(); i++)
  11.     {
  12.         f[i] = new int[C+1];
  13.     }
  14.     for(int i = 0; i < W.size(); i++)
  15.     {
  16.         f[i][0] = 0;
  17.     }
  18.     for(int i = 1; i < C+1; i++)
  19.     {
  20.         f[0][i] = (i < W[0])?0:V[0];
  21.     }
  22.     for(int i = 1; i < W.size(); i++)
  23.     {
  24.         for(int y = 1; y < C+1; y++)
  25.         {
  26.             if(y < W[i])
  27.             {
  28.                 f[i][y] = f[i-1][y];
  29.             } else {
  30.                 f[i][y] = (f[i-1][y] > (f[i-1][y-W[i]]+V[i]))?f[i-1][y]:(f[i-1][y-W[i]]+V[i]);
  31.             }
  32.         }
  33.     }
  34.     value = f[W.size()-1][C];
  35.     int j = W.size()-1;
  36.     int y = C;
  37.     while(j)
  38.     {
  39.         if(f[j][y] == (f[j-1][y-W[j]]+V[j]))
  40.         {
  41.             res[j] = 1;
  42.             y -= W[j];
  43.         }
  44.         j--;
  45.     }
  46.     res[0] = (f[0][y])?1:0;
  47.     for(int i = 0; i < W.size(); i++)
  48.     {
  49.         delete f[i];
  50.         f[i] = 0;
  51.     }
  52.     delete [] f;
  53.     f = 0;
  54.     return value;
  55. }
  57. void test1()
  58. {
  59.     int n, C;
  60.     while(cin >> n >> C)
  61.     {
  62.         vector<int> W;
  63.         vector<int> V;
  64.         int *N = new int[n];
  65.         int w, v, n1, i = 0;
  66.         while(i < n)
  67.         {
  68.             cin >> w >> v >> n1;
  69.             N[i] = n1;
  70.             while(n1--)
  71.             {
  72.                 W.push_back(w);
  73.                 V.push_back(v);
  74.             }
  75.             i++;
  76.         }
  77.         vector<int> res;
  78.         for(int i = 0;i < W.size(); i++)
  79.             res.push_back(0);
  80.         int value = knapsack_limitnum(W, V, res, C);
  81.         cout << value << endl;
  82.         i = 0;
  83.         int j = 0;
  84.         int count = 0, sum = N[i];
  85.         while(j < res.size())
  86.         {
  87.             if(j < sum)
  88.             {
  89.                 if(res[j])
  90.                     count++;
  91.             } else {
  92.                 cout << count << " ";
  93.                 i++;
  94.                 sum += N[i];
  95.                 count = (res[j])?1:0;
  96.             }
  97.             j++;
  98.         }
  99.         cout << count << endl;
  100.         delete N; N = 0;
  101.     }
  102. }
  104. int main()
  105. {
  106.     test1();
  107.     return 0;
  108. }

输入示例：

  1. 3 8           //3件物品，背包承重最大为8
  2. 1 6 10        //第一件物品， 重量为1，价值为6， 数目为10
  3. 2 10 5
  4. 2 20 2

执行结果：

  1. 64            //原问题的解，在背包承重为8中放3种物品最大价值为64
  2. 4 0 2         //最优解对应第一件物品放4个，第二件物品放0个，第三件物品放2个，即4*6+0*10+2*20 = 64

发表评论

表情：
评论列表 （有 0 条评论，404人围观）

还没有评论，来说两句吧...

相关阅读