01背包之再理解

       想要学习动态规划，从01背包问题入手，看了许多大牛的博客，各种优化各种讲解，讲的都不错，但是都是快速阅读，不求甚解，几天下来除了记住状态转移方程之外无甚收获，而且学的囫囵吞枣，说会不算会，说不会又冤得慌，如鲠在喉，终于下定决心搞个清楚，梳理整齐。

        注意，这些东西都不是我自己的想法，只是想把看的理解的东西记下来。会引用甚至摘抄原文。

        1.1 、01背包的题目： 有n件物品和一个容量为V 的背包。放入第i件物品耗费的空间是wi，得到的价值是vi。求解将哪些物品装入背包可使价值总和最大。

        1.2、 基本思路  ：这是最基础的背包问题，特点是：每种物品仅有一件，可以选择放或不放。
              用子问题定义状态：即dp[i, v]表示前i件物品恰放入一个容量为v的背包可以获得的最大价值。则其状态转移方程便是：

                          dp[i][v]=max(dp[i-1][v],dp[i-1][V-w[i]]+v[i]);（大写V表示可用空间，小写v指当前物品的价值（value） ）

 每一件物品选择放或者不放，就是动态规划中的决策，而dp【i】【v】及其意义就是状态，这两点很重要，非常重要。（因为我们面对一道动态规划题目。首先要识别子问题（把问题的规模缩小，先写出边界情况，用归纳法尝试找规律，然后取任意值i，考虑i的状态与i-1的状态之间的转换关系） ，然后定义状态，最后根据决策来建立状态转移方程。）

                      这个方程非常重要，基本上所有跟背包相关的问题的方程都是由它衍生出来的。所以有必要将它详细解释一下：“将前i件物品放入容量为V的背包中”这个子问题，若只考虑第i件物品的策略（放或不放），那么就可以转化为一个只和前i − 1件物品相关的问题。如果不放第i件物品，那么问题就转化为“前i − 1件物品放入容量为V的背包中”，价值为dp[i − 1, V]；如果放第i件物品，那么问题就转化为“前i − 1件物品放入剩下的容量为V − wi的背包中”，此时能获得的最大价值就是dp[i − 1, V − wi]再加上通过放入第i件物品获得的价值vi。

伪代码： 

                                dp[0, 0..V ] = 0
                                for i = 1 to n
                                    for j = wi to V
                                         dp[i, v] = max{dp[i − 1, j], dp[i − 1, j − wi] + vi}

C：10   N：5

Wi      Vi

4        9

3        6

5        1

2        4

5        1

	0	1	2	3	4	5	6	7	8	9	10
0	0	0	0	0	0	0	0	0	0	0	0
1	0	0	0	0	9	9	9	9	9	9	9
2	0	0	0	6	9	9	9	15	15	15	15
3	0	0	0	6	9	9	9	15	15	15	15
4	0	0	4	6	9	10	13	15	15	19	19
5	0	0	4	6	9	10	13	15	15	19	19

<pre name="code" class="cpp">#include<iostream>
#include<cstring>
using namespace std;
int main()
{
	int V,n;
	while(cin>>V>>n)
	{
		int dp[100][100];
		memset(dp,0,sizeof(dp));
		int w[100];
		int v[100];
		for(int i =1;i <=n;i++ )
		  cin>>w[i]>>v[i];
		for(int i =1; i<= n;i ++){
			for(int j = 1;j <= V; j++){
			    if(j>=w[i]) dp[i][j]=max(dp[i-1][j],dp[i-1][j-w[i]]+v[i]);
				else if(j<w[i])   dp[i][j]=dp[i-1][j];
			}
		}
		for(int i = 0;i <= n;i++){
			for(int j = 0; j <= V; j++){
				cout<<dp[i][j]<<" ";
			}
			cout<<endl;
		}
	}
	return 0;
}

好了，写好了代码，我们就开始优化吧，有些题目要求开的数组太大，如果用二维的话可能会编译器报错那么代码就要优化。

首先，我们观察上面的代码，发现我们的w和v数组只用了一次，因此，我们可以将这两个数组设置为两个变量，w和v。这样优化之后代码可以写成这样

#include<iostream>
using namespace std;
int main()
{
	int V,n;
	while(cin>>V>>n)
	{
		int w, v;
		int dp[100][100];
                for(int i = 0;i <= n;i ++){
        	    if(i) cin>>w>>v;
        	    for(int j = w; j <= V; j ++ ){
        		if(i) dp[i][j]=max(dp[i-1][j],dp[i-1][j-w]+v);
        		else dp[i][j]=0;
        	}
        }
        cout<<dp[n][V]<<endl;
	}
	return 0;
}

然后继续优化，那个二维数组看起来那么炸眼！

先贴代码： 

#include<iostream>
#include<cstring>
using namespace std;
int main()
{
	int V,n;
	while(cin>>V>>n)
	{
		int w,v;
		int *dp = new int[V+1];
		memset(dp,0,(V+1)*sizeof(int));
		for(int i = 1;i <= n;i++){
			cin>>w>>v;
			for(int j = V; j >= 0;j--){
				if(j >= w) dp[j] = max(dp[j],dp[j-w]+v);
				else dp[j]=dp[j];
			}
		}
                cout<<dp[V]<<endl;
	}
	return 0;
}

仔细看，看到差别没有？第二个for循环是从V到0的，是逆序滴！为啥？待我慢慢抄来。。。。

将i方向的维数去掉， 我们可以将原来二维数组表示为一维数据：d(i-1, j-V)变为d(j-V)， d(i-1, j)变为d(j)。当我们要计算d(i, j)时，只需要比较d(j)和d(j-V)+W的大小， 用较大的数更新d(j)即可。等等，如果我要计算d(i, j+1)，而它恰好要用到d(i-1, j)的值， 那么问题就出来了，因为你刚刚才把它更新为d(i, j)了。那么，怎么办呢？ 按照j递减的顺序即可避免这种问题。比如，你计算完d(i, j)， 接下来要计算的是d(i,j-1)，而它的状态转移方程为d(i, j-1)=max{ d(i-1, j-1), d(i-1, j-1-V)+W }，它不会再用到d(i-1,j)的值！所以， 即使该位置的值被更新了也无所谓。

仔细想想这段话哈，再看看图就明白了，当我们求dp[i][j]的时候用到了dp[i][j-v]和dp[i][j]，那么又怎么会阻碍dp[i][j+1]了呢？想想我们在求dp【i】【j】的时候就可能把dp【i-1】【j】或者dp【i】【j-v】改变了，（由于是一维数组，被改变之后就被替换了），但是当j增加的时候，dp【i】【j+1】又可能用到原来的dp【i-1】【j】，但是遗憾的是他已经不是原来的他了（真正的原因是为了保证每件物品只是用一次，对比完全背包的内循环就是顺序的，也就是说完全背包的物品可以多次使用）。。。这样就不好了么，那么怎么办呢，让内循环从大到小呗，等于是二维数组的每一行都从右往左填充，这样的话填充过dp【i】【j+1】再填充dp【i】【j】这样使用上一行的数组就不会起冲突了。

然后呢？然后敌人向我们提出了更加苛刻的要求。。。。。他们想要知道都有哪些物品被装进了背包，而哪些没有装。。。。

这个方法待我慢慢抄来。。。上代码

int j = V;
for(int i=n; i>0; --i){
    if(d[i][j] > d[i-1][j]){
        x[i] = 1;
        j = j - w[i];//装入第i-1个宝石后背包能装入的体积就只剩下j - V[i-1]
    }
}
for(int i=1; i<=n; ++i)  printf("%d ", x[i]);

解释： 

让我们先定义一个数组x，对于其中的元素为1时表示对应编号的物品放入背包， 为0则不放入。举个例子，对于体积为5，4，3，价值为20，10，12的3个宝石 ，如何求得其对应的数组x呢？（明显我们目测一下就知道x={1 0 1}， 但程序可目测不出来）OK，让我们还是从状态说起。如果我们把3号放入了背包， 那么是不是也就意味着，前3个物品放入背包的最大价值要比前2个物品放入背包的价值大， 即：dp(3, 10)>dp(2, 10)。再用字母代替具体的数字 （不知不觉中我们就用了不完全归纳法哈），当dp(i, j)>dp(i-1, j)时，x(i)=1;

完整代码： 

#include<iostream>
#include<cstring>
using namespace std;
int main()
{
	int V,n;
	while(cin>>V>>n)
	{
		int dp[100][100];
		int w[1000],v[1000];
		for(int i = 1;i <= n;i++)
		   cin>>w[i]>>v[i];
        for(int i = 0;i <= V;i++)
           dp[0][i]=0;
		for(int i = 1;i <= n;i++){
			for(int j = V; j>=w[i];j--){
				 dp[i][j]=max(dp[i-1][j],dp[i-1][j-w[i]]+v[i]);
			}
		}
		cout<<dp[n][V]<<endl;
		int j=V;
		int x[1000];
		memset(x,0,sizeof(x));
		for(int i = n;i >= 1;i--){
			if(dp[i][j]>dp[i-1][j]){
			     x[i]=1;
			     j-=w[i];
			}
		}
		for(int i = 1;i <= n;i++)
              cout<<x[i]<<" ";
  		cout<<endl;
		
	}
	return 0;
}

使用这种技巧好像数组就没法优化了。。。

完 了？还没有。。。。

背包九讲里面还有一个问题提到， 初始化的细节问题，我们看到的求最优解的背包问题题目中，事实上有两种不太相同的问法。
有的题目要求“恰好装满背包”时的最优解，有的题目则并没有要求必须把背包装满。一种区别这两种问法的实现方法是在初始化的时候有所不同。如果是第一种问法，要求恰好装满背包，那么在初始化时除了F[0]为0，其它F[1..V ]均设为−∞，这样就可以保证最终得到的F[V ]是一种恰好装满背包的最优解。如果并没有要求必须把背包装满，而是只希价格尽量大，初始化时应该将F[0..V ]全部设为0。这是为什么呢？可以这样理解：初始化的F数组事实上就是在没有任何物品可以放入背包时的合法状态。如果要求背包恰好装满，那么此时只有容量为0的背包可以在什么也不装且价值为0的情况下被“恰好装满”，其它容量的背包均没有合法的解，属于未定义的状态，应该被赋值为-∞了。如果背包并非必须被装满，那么任何容量的背包都有一个合法解“什么都不装”，这个解的价值为0，所以初始时状态的值也就全部为0了。这个小技巧完全可以推广到其它类型的背包问题。

讲的多好呀。。。