01背包

01背包

    问题描述：

        有n件物品和一个容量为v的背包。放入第i件物品的占的空间为Ci,得到的价值是Wi,求解将哪些物品装入背包可以

         使得总价值最大；

        首先要明白这个问题不能用贪心来做，因为当前的选择会影响到以后的选择，也就是说当前的选择的最优解

        可能会影响到全局的最优解；

       考虑用动态规划来做

           1.定义状态：

                    定义状态dp[i][j]为前i件物品恰放入容量为j的背包时的最大价值；

                    那么dp[n][v]就是这个问题的最终解；

           2.描述不同状态如何转移： 

                     在这个过程中，我们很自然想到的决策就是第i件物品放还是不放；放与不放会直接影响到dp[i][j]的值；

                    1.放，那么dp[i][j]的状态可由dp[i-1][j-Ci] + Wi转移过来

                    2.不放，那么dp[i][j]的状态可由dp[i-1][j]转移过来

                    我们所要做的就是在这两种决策中选取一种最优的；

                      所以状态转移方程为dp[i][j] = max(dp[i-1][j-Ci] + Wi , dp[i-1][j]);

            3.按一个方向求出该问题的解

                     状态dp[i][j]总是要取决于之前的状态dp[i-1][j-Ci] + Wi,dp[i-1][j],所以我们应按按自底而上的方向求解

代码如下：

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
 
const int INF = 2005;
int dp[INF][INF];	//定义状态dp[i][j]为前i件物品放入容量为j的背包时的最大价值；
int W[INF],C[INF];
 
 
int main()
{
	int n, v;
	scanf("%d%d",&n,&v);
		
	for(int i = 1; i <= n; i++)
	{
		scanf("%d",&W[i]);
	}
		
	for(int i = 1; i <= n; i++)
	{
		scanf("%d",&C[i]);
	}
		
	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] = max(dp[i-1][j],dp[i-1][j - C[i]] + W[i]);	//状态转移 
			}
			else
			{
				dp[i][j] = dp[i-1][j];
			}
		}
	}
	printf("%d\n",dp[n][v]);
	return 0;
} 

 

      当然，除了这种状态，我们可以定义另外一种状态来解决01背包问题

            1.定义状态：

                    定义状态dp[i][j]为前i个物品中价值为j时的耗费的最小空间；

             2.描述不同状态如何转移：

                    在这个过程中，我们能够很自然的想到当前物品的选与不选会影响当前状态；

                    1.放，那么状态dp[i][j]的状态可由状态dp[i-1][j-W[i]] + C[i]转移过来

                    2.不放，那么状态dp[i][j]的状态可由状态dp[i-1][j]转移过来

                     所以状态转移方程为dp[i][j] = min(dp[i-1][j-W[i] + C[i] , dp[i-1][j]);

             3.自底而上的求解

                    注意初始化，dp[0][0]为[0],dp[0][j]为不合法的状态，用一个无穷大的数代替；

                    在把所有状态求出来之后，我们只需要找出dp[n][j]不大于V的最大j值即可

 

代码如下：

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
const int INF = 2005;
 
int dp[INF][INF];		//定义状态dp[i][j]为前i个物品中价值为j时的耗费的最小空间；
						//这种状态只适用于C[i]的值很大，而W[i]的值较小的情况 
 
int W[INF],C[INF];
 
int main()
{
	int T;
	scanf("%d",&T);
	int n, v;
	scanf("%d%d",&n,&v);
		
	for(int i = 1; i <= n; i++)
	{
		scanf("%d",&W[i]);
	}
	for(int i = 1; i <= n; i++)
	{
		scanf("%d",&C[i]);
	}
	memset(dp,0,sizeof(dp));	//初始化 
	for(int i = 1; i < INF; i++)
	{
		dp[0][i] = INF + 5;
	}
		
	for(int i = 1; i <= n; i++)
	{
		for(int j = 0; j <= INF; j++) 
		{
			if(j >= W[i])
			{
				dp[i][j] = min(dp[i-1][j],dp[i-1][j - W[i]] + C[i]);	//状态转移方程 
			}
			else
			{
				dp[i][j] = dp[i-1][j];
			}
		}
	}
		
	int res = -1;
		
	for(int j = 0; j < INF; j++)if(dp[n][j] <= v)	//根据定义的状态可得结果是dp[n][j]不大于V的最大j值即可 
	{
		res = j;
	}
	printf("%d\n",res);
	
	
	
	
	
	return 0;
}