• 背包问题九讲笔记_01背包（转）

     http://blog.csdn.net/insistgogo/article/details/8579597

    背包问题九讲笔记_01背包

    分类： 算法导论2013-02-13 09:17 1752人阅读 评论(4) 收藏 举报

    摘自Tianyi Cui童鞋的《背包问题九讲》，稍作修改，方便理解。

    01背包问题描述

    已知:有一个容量为V的背包和N件物品，第i件物品的重量是weight[i]，收益是cost[i]。

    限制:每种物品只有一件，可以选择放或者不放

    问题:在不超过背包容量的情况下，最多能获得多少价值或收益

    相似问题:在恰好装满背包的情况下，最多能获得多少价值或收益

    这里，我们先讨论在不超过背包容量的情况下，最多能获得多少价值或收益。

    基本思路

    01背包的特点:每种物品只有一件，可以选择放或者不放

    子问题定义状态

    [cpp] view plaincopy
    1. f[i][v] : 前i件物品放到一个容量为v的背包中可以获得最大价值  

    状态转移方程

    [cpp] view plaincopy
    1. f[i][v] = max(f[i - 1][v],f[i - 1][v - weight[i]] + cost[i])  

    分析

    考虑我们的子问题，将前i件物品放到容量为v的背包中，若我们只考虑第i件物品时，它有两种选择，放或者不放。

    1) 如果第i件物品不放入背包中，那么问题就转换为：将前i - 1件物品放到容量为v的背包中，带来的收益f[i - 1][v]

    2) 如果第i件物品能放入背包中，那么问题就转换为：将前i - 1件物品放到容量为v - weight[i]的背包中，带来的收益f[i - 1][v - weight[i]] + cost[i]

    代码

    [cpp] view plaincopy
    1. #include <iostream>  
    2. using namespace std;  
    3.   
    4. const int N = 3;//物品个数  
    5. const int V = 5;//背包最大容量  
    6. int weight[N + 1] = {0,3,2,2};//物品重量  
    7. int value[N + 1] = {0,5,10,20};//物品价值  
    8.   
    9. int f[N + 1][V + 1] = {{0}};  
    10.   
    11. int Max(int x,int y)  
    12. {  
    13.     return x > y ? x : y;  
    14. }  
    15.   
    16. /* 
    17. 目标：在不超过背包容量的情况下，最多能获得多少价值 
    18.  
    19. 子问题状态:f[i][j]:表示前i件物品放入容量为j的背包得到的最大价值 
    20.  
    21. 状态转移方程:f[i][j] = max{f[i - 1][j],f[i - 1][j - weight[i]] + value[i]} 
    22.  
    23. 初始化:f数组全设置为0 
    24. */  
    25. int Knapsack()  
    26. {  
    27.     //初始化  
    28.     memset(f,0,sizeof(f));  
    29.     //递推  
    30.     for (int i = 1;i <= N;i++) //枚举物品  
    31.     {  
    32.         for (int j = 0;j <= V;j++) //枚举背包容量  
    33.         {  
    34.             f[i][j] = f[i - 1][j];  
    35.             if (j >= weight[i])  
    36.             {  
    37.                 f[i][j] = Max(f[i - 1][j],f[i - 1][j - weight[i]] + value[i]);  
    38.             }  
    39.         }  
    40.     }  
    41.     return f[N][V];  
    42. }  
    43.   
    44. int main()  
    45. {  
    46.     cout<<Knapsack()<<endl;  
    47.     system("pause");  
    48.     return 1;  
    49. }  

    效率分析：

    此算法的时间复杂度为O(N*V)，空间复杂度也为O(N*V)。其中，N 表示物品个数，V 表示背包容量这里，时间复杂度不可以在优化了，但是空间复杂度可以继续优化到O(V)

    优化空间复杂度

    上述的方法，我们使用二维数组 f[i][v] 保存中间状态，这里我们可以使用一维数组f[v]保存中间状态就能得到结果

    分析

    我们现在使用f[v]保存中间状态，我们想要达到的效果是，第i次循环后，f[v]中存储的是前i个物体放到容量v时的最大价值

    在回顾下之前讲过的状态转移方程：

    [cpp] view plaincopy
    1. f[i][v] = max(f[i - 1][v],f[i - 1][v - weight[i]] + cost[i])  

    我们可以看到，要想得到 f[i][v]，我们需要知道 f[i - 1][v] 和 f[i - 1][v - weight[i]]，由于我们使用二维数组保存中间状态，所以可以直接取出这两个状态。

    当我们使用一维数组存储状态时，f[v]表示，在执行i次循环后(此时已经处理i个物品)，前i个物体放到容量v时的最大价值，即之前的f[i][v]。与二维相比较，它把第一维隐去了，但是二者表达的含义还是相同的，只不过针对不同的i，f[v]一直在重复使用，所以，也会出现第i次循环可能会覆盖第i - 1次循环的结果。

    为了求f[v],我们需要知道，前i - 1个物品放到容量v的背包中带来的收益，即之前的f[i - 1][v]  和 前i - 1件物品放到容量为v - weight[i]的背包中带来的收益，即之前的f[i - 1][v - weight[i]] + cost[i]。

    难点：由于我们只使用一维数组存储，则在求这两个子问题时就没有直接取出那么方便了，因为，第i次循环可能会覆盖第i - 1次循环的结果。

    现在我们来求这两个值

    1）前i - 1个物品放到容量v的背包中带来的收益，即之前的f[i - 1][v] ：

    由于，在执行在i次循环时，f[v]存储的是前i个物体放到容量v时的最大价值，在求前i个物体放到容量v时的最大价值(即之前的f[i][v])时，我们是正在执行第 i 次循环，f[ v ]的值还是在第 i - 1  次循环时存下的值，在此时取出的 f[ v ]就是前i - 1个物体放到容量v时的最大价值，即f[i - 1][v]。

    2）前i - 1件物品放到容量为v - weight[i]的背包中带来的收益，即之前的f[i - 1][v - weight[i]] + cost[i]

    由于，在执行第i次循环前，f[0 ~ V]中保存的是第i - 1次循环的结果，即是前i - 1个物体分别放到容量0 ~ V时的最大价值，即f[i - 1][0 ~ V]。

    则，在执行第i次循环前，f 数组中v - weight[i]的位置存储就是我们要找的 前i - 1件物品放到容量为v - weight[i]的背包中带来的收益 (即之前的f[i - 1][v - weight[i]])，这里假设物品是从数组下标1开始存储的。

    伪代码

    [cpp] view plaincopy
    1. for i=1..N //枚举物品  
    2.     for v=V..0 //枚举容量，从大到小  
    3.         f[v]=max{f[v],f[v-weight[i]] + cost[i]};  

    由上面伪代码可知，在执行第 i 次循环时，需要把背包容量由V..0都要遍历一遍，检测第 i 件物品是否能放。

    逆序枚举容量的原因：

    注意一点，我们是由第 i - 1 次循环的两个状态推出 第 i 个状态的，而且 v  > v - weight[i]，则对于第i次循环，背包容量只有当V..0循环时，才会先处理背包容量为v的状况，后处理背包容量为 v-weight[i] 的情况。

    具体来说，由于，在执行v时，还没执行到v - weight[i]的，因此，f[v - weight[i]]保存的还是第i - 1次循环的结果。即在执行第i次循环 且 背包容量为v时，此时的f[v]存储的是 f[i - 1][v] ，此时f[v-weight[i]]存储的是f[i - 1][v-weight[i]]。

    相反，如果在执行第 i 次循环时，背包容量按照0..V的顺序遍历一遍，来检测第 i 件物品是否能放。此时在执行第i次循环 且 背包容量为v时，此时的f[v]存储的是 f[i - 1][v] ，但是，此时f[v-weight[i]]存储的是f[i][v-weight[i]]。

    因为，v  > v - weight[i]，第i次循环中，执行背包容量为v时，容量为v - weight[i]的背包已经计算过，即f[v - weight[i]]中存储的是f[i][v - weight[i]]。即，对于01背包，按照增序枚举背包容量是不对的。

    代码

    [cpp] view plaincopy
    1. #include <iostream>  
    2. using namespace std;  
    3.   
    4. const int N = 3;//物品个数  
    5. const int V = 5;//背包最大容量  
    6. int weight[N + 1] = {0,3,2,2};//物品重量  
    7. int value[N + 1] = {0,5,10,20};//物品价值  
    8.   
    9. int f[V + 1] = {0};  
    10.   
    11. int Max(int x,int y)  
    12. {  
    13.     return x > y ? x : y;  
    14. }  
    15.   
    16. /* 
    17. 目标：在不超过背包容量的情况下，最多能获得多少价值 
    18.  
    19. 子问题状态:f[j]:表示前i件物品放入容量为j的背包得到的最大价值 
    20.  
    21. 状态转移方程:f[j] = max{f[j],f[j - weight[i]] + value[i]} 
    22.  
    23. 初始化:f数组全设置为0 
    24. */  
    25. int Knapsack()  
    26. {  
    27.     //初始化  
    28.     memset(f,0,sizeof(f));  
    29.     //递推  
    30.     for (int i = 1;i <= N;i++) //枚举物品  
    31.     {  
    32.         for (int j = V;j >= weight[i];j--) //枚举背包容量,防越界，j下限为 weight[i]  
    33.         {  
    34.             f[j] = Max(f[j],f[j - weight[i]] + value[i]);  
    35.         }  
    36.     }  
    37.     return f[V];  
    38. }  
    39.   
    40. int main()  
    41. {  
    42.     cout<<Knapsack()<<endl;  
    43.     system("pause");  
    44.     return 1;  
    45. }  

    但是，增序枚举背包容量会达到什么效果：它会重复的装入某个物品，而且尽可能多的，使价值最大，当然不会不超过背包容量

    而逆序枚举背包容量：背包中的物品至多装一次，使价值最大，当然不会不超过背包容量

    我们首先举例说明：

    逆序枚举物品

    当i = 2，我们要求 f [5]：表示检测物品2放入容量为5的背包的最大收益

    上图表示，当i = 2，求f[5]时f数组的状况，

    橙色为数组现在存储的值，这些值是i = 1时(上一次循环)存入数组 f 的。相当于f[i - 1][v]

    而黄色使我们要求的值，在求f[5]之前，f[5]= 5，即f[i - 1][5] = 5

    现在要求 i = 2 时的f[5] = f[5 - 2] + 10 = 5 + 10 = 15  >  f[i - 1][5] = 5

    故，f[5] = 15；

    注意一点，在求f[v]时，它引用的 f[v - weight[i]] 和 f[v]都是上一次循环的结果

    顺序枚举物品

    当i = 2，我们要求 f [5]：表示检测物品2放入容量为5的背包的最大收益

    上图表示，当i = 2，求f[5]时f数组的状况，

    橙色为数组现在存储的值，这些值是i = 2时(本次循环)存入数组 f 的。相当于f[i][v]

    这是由于，我们是增序遍历数组f的，在求f[v]时，v之前的值(0 ~ v - 1)都已经在第i次循环中求出。

    而黄色使我们要求的值，在求f[5]之前，f[5]= 5，即f[i - 1][5] = 5

    现在要求 i = 2 时的f[5] = f[5 - 2] + 10 =10+ 10 = 20 >  f[i - 1][5] = 5

    故，f[5] = 20；

    其中引用的f[3]是相当于f[i][3] 而不是正常的f[i - 1][3]

    注意一点，在求f[v]时，它引用的 f[v - weight[i]]是本次循环的结果 而f[v]是上一次循环的结果

    换个角度说，

    在检测 背包容量为5时，看物品2是否加入

    由状态转移方程可知，我们f[5]需要引用自己本身和f[3]

    由于背包容量为3时，可以装入物品2，且收益比之前的大，所以放入背包了。

    在检测f[5]时，肯定要加上物品2的收益，而f[5]在引用f[3]时，f[3]时已经加过一次物品2，

    因此，在枚举背包容量时，物品2会加入多次。

    进一步说：

    我们观察一维状态转移方程：

    f[i][v] = max(f[i - 1][v],f[i - 1][v - weight[i]] + cost[i])

    首先我们明确三个问题

    1) v - weight[i] < v

    2) 状态f[i][v] 是由 f[i - 1][v] 和 f[i - 1][v - weight[i]] 两个状态决定

    3) 对于物品i，我们在枚举背包容量时，只要背包容量能装下物品i 且 收益比原来的大，就会成功放入物品i。

    具体来说，枚举背包容量时，是以递增的顺序的话，由于 v - weight[i] < v,则会先计算 v - weight[i]。在背包容量为v - weight[i]时，一旦装入了物品i，由于求f[v]需要使用f[i - 1][v - weight[i]]，而若求f[v]时也可以装入物品i的话，那么在背包容量为v时，容量为v的背包就装入可两次物品。又若v - weight[i]是由之前的状态推出，它们也成功装入物品i的话，那么容量为v的背包就装入了多次物品i了。

    注意，此时，在计算f[v]时，已经把物品i能装入的全装入容量为v的背包了，此时装入物品i的次数为最大啊

    其实，顺序枚举容量是完全背包问题最简捷的解决方案。

    初始化的细节问题

    求最优解的背包问题时，有两种问法：

    1)在不超过背包容量的情况下，最多能获得多少价值

    2)在恰好装满背包的情况下，最多能获得多少价值

    主要的区别为是否要求恰好装满背包。但这两种问法的实现方法是在初始化的时候有所不同。

    1)恰好装满背包的情况：使用二维数组f[i][v]存储中间状态，其中第一维表示物品，第二维表示背包容量

    初始化时，除了f[i][0] = 0（第一列）外，其他全为负无穷。

    原因：初始化 f 数组就是表示：在没有任何物品可以放入背包时的合法状态。对于恰好装满背包，只有背包容量为 0（第一列），可以什么物品都不装就能装满，这种情况是合法情况，此时价值为0。其他f[0][v]（第一列）是都不能装满的，此时有容量没物品。而其他位置（除去第一行和第一列的位置），我们为了在计算中比较最大值，也要初始化为负无穷。我们从程序的角度上看，我们只允许装入背包物品的序列的起始位置是从第一列开始，这些起始位置都是合法位置，且能恰好装满的情况收益均为正值，到f[N][V]终止。

    注意，我们虽然是求恰好装满，还是需要枚举所有可以装入背包的物品，只要能装入，还需装入，收益有增加。只不过，由于恰好装满的物品的序列肯定是从第一列某行开始的，且之后的收益肯定是正值。对于非恰好装满的物品序列，其实位置肯定是从第一行某位置开始的，由于此时被初始化为负无穷，在和那些恰好装满物品序列带来的价值时，肯定是小的。所以，我们最后能获得最大值。

    代码：

    [cpp] view plaincopy
    1. #include <iostream>  
    2. using namespace std;  
    3.   
    4. const int MinNum = 0x80000000;  
    5.   
    6. const int N = 3;//物品个数  
    7. const int V = 5;//背包最大容量  
    8. int weight[N + 1] = {0,3,2,2};//物品重量  
    9. int value[N + 1] = {0,5,10,20};//物品价值  
    10.   
    11. int f[N + 1][V + 1] = {{0}};  
    12.   
    13. int Max(int x,int y)  
    14. {  
    15.     return x > y ? x : y;  
    16. }  
    17.   
    18. /* 
    19. 目标：在恰好装满背包的情况下，最多能获得多少价值 
    20.  
    21. 子问题状态:f[i][j]:表示前i件物品放入容量为j的背包得到的最大价值 
    22.  
    23. 状态转移方程:f[i][j] = max{f[i - 1][j],f[i - 1][j - weight[i]] + value[i]} 
    24.  
    25. 初始化:f数组全设置为0 
    26. */  
    27. int Knapsack()  
    28. {  
    29.     //初始化  
    30.     for (int i = 0;i <= N;i++) //枚举物品  
    31.     {  
    32.         for (int j = 0;j <= V;j++) //枚举背包容量  
    33.         {  
    34.             f[i][j] = MinNum;  
    35.         }  
    36.     }  
    37.     for (int i = 0;i <= N;i++)  
    38.     {  
    39.         f[i][0] = 0;//背包容量为0时为合法状态  
    40.     }  
    41.     //递推  
    42.     for (int i = 1;i <= N;i++) //枚举物品  
    43.     {  
    44.         for (int j = 1;j <= V;j++) //枚举背包容量  
    45.         {  
    46.             f[i][j] = f[i - 1][j];  
    47.             if (j >= weight[i])  
    48.             {  
    49.                 f[i][j] = Max(f[i - 1][j],f[i - 1][j - weight[i]] + value[i]);  
    50.             }  
    51.         }  
    52.     }  
    53.     return f[N][V];  
    54. }  
    55.   
    56. int main()  
    57. {  
    58.     cout<<Knapsack()<<endl;//输出25  
    59.     system("pause");  
    60.     return 1;  
    61. }  

    使用一维数组f[v]存储中间状态，维表示背包容量

    初始化时，除了f[0] = 0，其他全为负无穷。

    原因：只有容量为0 的背包可以什么物品都不装就能装满，此时价值为0。其它容量的背包均没有合法的解，属于未定义的状态，应该被赋值为负无穷了

    代码

    [cpp] view plaincopy
    1. #include <iostream>  
    2. using namespace std;  
    3.   
    4. const int MinNum = 0x80000000;//int最小的数  
    5.   
    6. const int N = 3;//物品个数  
    7. const int V = 5;//背包最大容量  
    8. int weight[N + 1] = {0,3,2,2};//物品重量  
    9. int value[N + 1] = {0,5,10,20};//物品价值  
    10.   
    11. int f[V + 1] = {0};  
    12.   
    13. int Max(int x,int y)  
    14. {  
    15.     return x > y ? x : y;  
    16. }  
    17.   
    18. /* 
    19. 目标：在恰好装满背包容量的情况下，最多能获得多少价值 
    20.  
    21. 子问题状态:f[j]:表示前i件物品放入容量为j的背包得到的最大价值 
    22.  
    23. 状态转移方程:f[j] = max{f[j],f[j - weight[i]] + value[i]} 
    24.  
    25. 初始化:f数组全设置为0 
    26. */  
    27. int Knapsack()  
    28. {  
    29.     //初始化  
    30.     for (int i = 0;i <= V;i++)  
    31.     {  
    32.         f[i] = MinNum;  
    33.     }  
    34.     f[0] = 0;//只有背包容量为0时才是合法状态，由合法状态组成的结果才是合法的  
    35.   
    36.     //递推  
    37.     for (int i = 1;i <= N;i++) //枚举物品  
    38.     {  
    39.         for (int j = V;j >= weight[i];j--) //枚举背包容量,防越界，j下限为 weight[i]  
    40.         {  
    41.             f[j] = Max(f[j],f[j - weight[i]] + value[i]);  
    42.         }  
    43.     }  
    44.     return f[V];  
    45. }  
    46.   
    47. int main()  
    48. {  
    49.     cout<<Knapsack()<<endl;//输出25  
    50.     system("pause");  
    51.     return 1;  
    52. }  

    2)不需要把背包装满，只需要收益最大

    使用二维数组f[i][v]存储中间状态，其中第一维表示物品，第二维表示背包容量

    初始化时，除了f[i][0] = 0（第一列）外，其他全为负无穷。

    使用一维数组f[v]存储中间状态，维表示背包容量

    原因：如果背包并非必须被装满，那么任何容量的背包都有一个合法解“什么都不装”，这个解的价值为0，所以初始时状态的值也就全部为0了。

    代码在最前面已贴，不在此上传。

    一个常数优化

    一维数组描述状态时的伪代码：

    [cpp] view plaincopy
    1. for i=1..N //枚举物品  
    2.     for v=V..0 //枚举容量，从大到小  
    3.         f[v]=max{f[v],f[v-weight[i]] + cost[i]};  

    观察可知，对于第i个物品，枚举背包容量下限时，可以到weight[i]为止。

    原因：

    1）对于第i物品，在求f[v]时，需要使用的状态是 v ~ v -  weight[i] 这么多，这是由于v取最大容量V时，使用的状态才是v - weight[i]，当v不取最大状态时，使用的状态肯定是在v ~ v -  weight[i]之间的。可以到weight[i]为止。

    2）在到weight[i]为止时，还可以不进行if判断，担心v -  weight[i]是否越界

    此时，伪代码为

    [cpp] view plaincopy
    1. for i=1..N //枚举物品  
    2.     for v=V..weight[i] //枚举容量，从大到小  
    3.         f[v]=max{f[v],f[v-weight[i]] + cost[i]};  

    注意，对 f 数组，如果是检测第i个物品是否能放入，0 ~ weight[i] - 1的这些位置是不会遍历到的，则此时他们仍表示第i - 1次的状态，即二维的f[i - 1][v]。

    还可以继续优化下界为

    [cpp] view plaincopy
    1. for i=1..N //枚举物品  
    2.     bound=max{V-sum{weight[i..n]},weight[i]}//确定需要枚举容量的下界  
    3.     for v=V..bound  
    4.         f[v]=max{f[v],f[v-weight[i]] + cost[i]};  

    原因：

    1)网上的说法,不太懂,各位大牛可以指导下下。

    对于第i次循环（指外循环），对于背包容量v = V(最大)时，对于f[v]的值，其实只要知道f[v-weight[i]]即可。以此类推，对于背包容量为 j 时，我们只需要知道到f[v-sum{weight[j..n]}]即可

    2)还有人说

    如果比v-sum{weight[j..n]}这个小，那么即使后面物品的全要也装不满背包。

    所以对于物品i，小于v-sum{weight[j..n]}的v值，无意义。

    总之是不懂。智商啊

    作者说，当V很大是，效果好。

    代码

    [cpp] view plaincopy
    1. #include <iostream>  
    2. using namespace std;  
    3.   
    4. const int N = 3;//物品个数  
    5. const int V = 5;//背包最大容量  
    6. int weight[N + 1] = {0,3,2,2};//物品重量  
    7. int value[N + 1] = {0,5,10,20};//物品价值  
    8.   
    9. int f[V + 1] = {0};  
    10.   
    11. int Max(int x,int y)  
    12. {  
    13.     return x > y ? x : y;  
    14. }  
    15.   
    16. /* 
    17. 目标：在不超过背包容量的情况下，最多能获得多少价值 
    18.  
    19. 子问题状态:f[j]:表示前i件物品放入容量为j的背包得到的最大价值 
    20.  
    21. 状态转移方程:f[j] = max{f[j],f[j - weight[i]] + value[i]} 
    22.  
    23. 初始化:f数组全设置为0 
    24. */  
    25. int Knapsack()  
    26. {  
    27.     int sum = 0;//存储还未处理物品的总容量  
    28.     int bound = 0;  
    29.     //初始化  
    30.     memset(f,0,sizeof(f));  
    31.     for (int i = 1;i <= N;i++)  
    32.     {  
    33.         sum += weight[i];  
    34.     }  
    35.       
    36.     //递推  
    37.     for (int i = 1;i <= N;i++) //枚举物品  
    38.     {  
    39.         //设置下界  
    40.         if (i != 1)  
    41.         {  
    42.             sum -= weight[i - 1];  
    43.         }  
    44.         bound = Max(V - sum,weight[i]);  
    45.   
    46.         for (int j = V;j >= bound;j--) //枚举背包容量  
    47.         {  
    48.             if (f[j] < f[j - weight[i]] + value[i])  
    49.             {  
    50.                 f[j] = f[j - weight[i]] + value[i];  
    51.             }  
    52.         }  
    53.     }  
    54.     return f[V];  
    55. }  
    56.   
    57. int main()  
    58. {  
    59.     cout<<Knapsack()<<endl;  
    60.     system("pause");  
    61.     return 1;  
    62. }  

     输出方案

    一般而言，背包问题是要求一个最优值，如果要求输出这个最优值的方案，可以参照一般动态规划问题输出方案的方法：记录下每个状态的最优值是由状态转移方程的哪一项推出来的，换句话说，记录下它是由哪一个策略推出来的。便可根据这条策略找到上一个状态，从上一个状态接着向前推即可。

    这里我们首先给出01背包的二维状态转移方程

    [cpp] view plaincopy
    1. f[i][v] = max(f[i - 1][v],f[i - 1][v - weight[i]] + cost[i])  

    对于状态f[i][v]，它来自两种策略，可以是f[i - 1][v],也可以是f[i - 1][v - weight[i]] + cost[i]

    其中，对于第二种情况，就是把物品i放入背包了，这里也是我们要找的情况

    根据状态转移方程，我们可以给出两种实现方法

    1) 借助存储状态的数组，直接根据状态转移方程倒着推，检测是否满足

    [cpp] view plaincopy
    1. f[i][v] == f[i - 1][v - weight[i]] + value[i]  

    如果满足，则把第i件物品放入了，此时我们要检测第i - 1件物品，背包容量为v - weight[i]

    不满足则表示没有把第i件物品放入，直接检测第i - 1件物品，此时背包容量还是v

    注意，这种方法只适用于存储状态数组不压缩的情况。压缩数组由于数据有覆盖，不能使用

    代码

    [cpp] view plaincopy
    1. #include <iostream>  
    2. using namespace std;  
    3.   
    4. const int N = 3;//物品个数  
    5. const int V = 5;//背包最大容量  
    6. int weight[N + 1] = {0,3,2,2};//物品重量  
    7. int value[N + 1] = {0,5,10,20};//物品价值  
    8.   
    9. int f[N + 1][V + 1] = {{0}};  
    10.   
    11. int Max(int x,int y)  
    12. {  
    13.     return x > y ? x : y;  
    14. }  
    15.   
    16. /* 
    17. 目标：在不超过背包容量的情况下，最多能获得多少价值 
    18.  
    19. 子问题状态:f[i][j]:表示前i件物品放入容量为j的背包得到的最大价值 
    20.  
    21. 状态转移方程:f[i][j] = max{f[i - 1][j],f[i - 1][j - weight[i]] + value[i]} 
    22.  
    23. 初始化:f数组全设置为0 
    24. */  
    25. int Knapsack()  
    26. {  
    27.     //初始化  
    28.     memset(f,0,sizeof(f));  
    29.     //递推  
    30.     for (int i = 1;i <= N;i++) //枚举物品  
    31.     {  
    32.         for (int j = 1;j <= V;j++) //枚举背包容量  
    33.         {  
    34.             f[i][j] = f[i - 1][j];  
    35.             if (j >= weight[i])  
    36.             {  
    37.                 f[i][j] = Max(f[i - 1][j],f[i - 1][j - weight[i]] + value[i]);  
    38.             }  
    39.         }  
    40.     }  
    41.     return f[N][V];  
    42. }  
    43. /* 
    44. 输出顺序:逆序输出物品编号 
    45. 注意：这里借助状态数组f[i][v] 
    46. 使用状态转移方程:f[i][j] = max{f[i - 1][j],f[i - 1][j - weight[i]] + value[i]} 
    47. */  
    48. void PrintKnapsack()  
    49. {  
    50.     int i = N;//枚举物品  
    51.     int j = V;//枚举空间  
    52.       
    53.     cout<<"加入背包的物品编号:"<<endl;  
    54.     while(i)  
    55.     {  
    56.         if (f[i][j] == f[i - 1][j - weight[i]] + value[i])  
    57.         {  
    58.             /*if不满足，表示第i件物品没装入背包, 
    59.               if条件满足，表示放入背包了*/  
    60.             cout<<i<<" ";  
    61.             j -= weight[i];//此时容量减少  
    62.         }  
    63.         i--;  
    64.     }  
    65.     cout<<endl;  
    66. }  
    67.   
    68. /* 
    69. 输出顺序:顺序输出物品编号 
    70. 注意：这里借助状态数组f[i][v] 
    71. 使用状态转移方程:f[i][j] = max{f[i - 1][j],f[i - 1][j - weight[i]] + value[i]} 
    72. */  
    73. void PrintKnapsack_recursion(int i,int j)  
    74. {  
    75.     if (i == 0 || j == 0)  
    76.     {  
    77.         return;  
    78.     }  
    79.     if (f[i][j] == f[i - 1][j - weight[i]] + value[i])  
    80.     {  
    81.         PrintKnapsack_recursion(i - 1,j - weight[i]);  
    82.         cout<<i<<" ";  
    83.     }  
    84. }  
    85.   
    86. int main()  
    87. {  
    88.     cout<<Knapsack()<<endl;  
    89.     PrintKnapsack();  
    90.     PrintKnapsack_recursion(N,V);  
    91.     system("pause");  
    92.     return 1;  
    93. }  

    2) 另外开辟数组，在求解最大收益时做标记位。求解完最大收益后，根据这个新数组倒着推结果

    思想：对于现在这个状态的位置，它存储的是该状态上一位置

    注意：这种方法均适用存储状态数组不压缩 和 压缩两种情况

    代码：

    [cpp] view plaincopy
    1. #include <iostream>  
    2. using namespace std;  
    3.   
    4. const int N = 3;//物品个数  
    5. const int V = 5;//背包最大容量  
    6. int weight[N + 1] = {0,3,2,2};//物品重量  
    7. int value[N + 1] = {0,5,10,20};//物品价值  
    8.   
    9. int f[V + 1] = {0};  
    10.   
    11. int G[N + 1][V + 1] = {{0}};//求背包序列  
    12.   
    13. int Max(int x,int y)  
    14. {  
    15.     return x > y ? x : y;  
    16. }  
    17.   
    18. /* 
    19. 目标：在不超过背包容量的情况下，最多能获得多少价值 
    20.  
    21. 子问题状态:f[j]:表示前i件物品放入容量为j的背包得到的最大价值 
    22.  
    23. 状态转移方程:f[j] = max{f[j],f[j - weight[i]] + value[i]} 
    24.  
    25. 初始化:f数组全设置为0 
    26. */  
    27. int Knapsack()  
    28. {  
    29.     //初始化  
    30.     memset(f,0,sizeof(f));  
    31.     memset(G,0,sizeof(G));  
    32.     //递推  
    33.     for (int i = 1;i <= N;i++) //枚举物品  
    34.     {  
    35.         for (int j = V;j >= weight[i];j--) //枚举背包容量  
    36.         {  
    37.             if (f[j] < f[j - weight[i]] + value[i])  
    38.             {  
    39.                 f[j] = f[j - weight[i]] + value[i];  
    40.                 G[i][j] = 1;  
    41.             }  
    42.         }  
    43.     }  
    44.     return f[V];  
    45. }  
    46. /* 
    47. 输出顺序:逆序输出物品编号 
    48. 注意：这里另外开辟数组G[i][v],标记上一个状态的位置 
    49. G[i][v] = 1:表示物品i放入背包了，上一状态为G[i - 1][v - weight[i]] 
    50. G[i][v] = 0:表示物品i没有放入背包，上一状态为G[i - 1][v] 
    51. */  
    52. void PrintKnapsack()  
    53. {  
    54.     int i = N;//枚举物品  
    55.     int j = V;//枚举空间  
    56.       
    57.     cout<<"加入背包的物品编号:"<<endl;  
    58.     while(i)  
    59.     {  
    60.         if (G[i][j] == 1)  
    61.         {  
    62.             /*if不满足，表示第i件物品没装入背包, 
    63.               if条件满足，表示放入背包了*/  
    64.             cout<<i<<" ";  
    65.             j -= weight[i];//此时容量减少  
    66.         }  
    67.         i--;  
    68.     }  
    69.     cout<<endl;  
    70. }  
    71.   
    72. /* 
    73. 输出顺序:顺序输出物品编号 
    74. 注意：这里另外开辟数组G[i][v],标记上一个状态的位置 
    75. G[i][v] = 1:表示物品i放入背包了，上一状态为G[i - 1][v - weight[i]] 
    76. G[i][v] = 0:表示物品i没有放入背包，上一状态为G[i - 1][v] 
    77. */  
    78. void PrintKnapsack_recursion(int i,int j)  
    79. {  
    80.     if (i == 0 || j == 0)  
    81.     {  
    82.         return;  
    83.     }  
    84.     if (G[i][j] == 1)  
    85.     {  
    86.         PrintKnapsack_recursion(i - 1,j - weight[i]);  
    87.         cout<<i<<" ";  
    88.     }  
    89. }  
    90.   
    91. int main()  
    92. {  
    93.     cout<<Knapsack()<<endl;  
    94.     PrintKnapsack();  
    95.     PrintKnapsack_recursion(N,V);  
    96.     system("pause");  
    97.     return 1;  
    98. }  

    小结：

    01 背包问题是最基本的背包问题，它包含了背包问题中设计状态、方程的最基本思想。另外，别的类型的背包问题往往也可以转换成01 背包问题求解。故一定要仔细体会上面基本思路的得出方法，状态转移方程的意义，以及空间复杂度怎样被优化。
  • 相关阅读:
    数据结构化与保存
    使用正则表达式，取得点击次数，函数抽离
    爬取校园新闻首页的新闻
    网络爬虫基础练习
    综合练习：词频统计
    Hadoop综合大作业
    理解MapReduce
    熟悉常用的Hbase操作
    熟悉的HDFS操作
    爬取晨星网对各公司主要职位的分析
  • 原文地址：https://www.cnblogs.com/XDJjy/p/3856508.html
Copyright © 2020-2023  润新知