01背包问题

1、动态规划（DP）

　　动态规划（Dynamic Programming，DP）与分治区别在于划分的子问题是有重叠的，解过程中对于重叠的部分只要求解一次，记录下结果，其他子问题直接使用即可，减少了重复计算过程。 
　　另外，DP在求解一个问题最优解的时候，不是固定的计算合并某些子问题的解，而是根据各子问题的解的情况选择其中最优的。 
　　动态规划求解具有以下的性质： 
　　最优子结构性质、子问题重叠性质　　 
　　最优子结构性质：最优解包含了其子问题的最优解，不是合并所有子问题的解，而是找最优的一条解线路，选择部分子最优解来达到最终的最优解。 
　　子问题重叠性质：先计算子问题的解，再由子问题的解去构造问题的解（由于子问题存在重叠，把子问题解记录下来为下一步使用，这样就直接可以从备忘录中读取）。其中备忘录中先记录初始状态。

2、求解思路

　　①、将原问题分解为子问题（子问题和原问题形式相同，且子问题解求出就会被保存）； 
　　②、确定状态：01背包中一个状态就是个物体中第个是否放入体积为背包中； 
　　③、确定一些初始状态（边界状态）的值； 
　　④、确定状态转移方程，如何从一个或多个已知状态求出另一个未知状态的值。（递推型）

3、01背包问题求解思路

　　①、确认子问题和状态 
　　01背包问题需要求解的就是，为了体积V的背包中物体总价值最大化，件物品中第件应该放入背包中吗？（其中每个物品最多只能放一件） 
　　为此，我们定义一个二维数组，其中每个元素代表一个状态，即前个物体中若干个放入体积为背包中最大价值。数组为：，其中表示前件中若干个物品放入体积为的背包中的最大价值。 
　　②、初始状态 
　　初始状态为和都为0，前者表示前0个物品（也就是空物品）无论装入多大的包中总价值都为0，后者表示体积为0的背包啥价值的物品都装不进去。 
　　③、转移函数

1. if (背包体积j小于物品i的体积)

2. f[i][j] = f[i-1][j] //背包装不下第i个物体，目前只能靠前i-1个物体装包

3. else

4. f[i][j] = max(f[i-1][j], f[i-1][j-Vi] + Wi)

　　最后一句的意思就是根据“为了体积V的背包中物体总价值最大化，件物品中第件应该放入背包中吗？”转化而来的。表示第件物体的体积，表示第件物品的价值。这样f[i-1][j]代表的就是不将这件物品放入背包，而f[i-1][j-Vi] + Wi则是代表将第i件放入背包之后的总价值，比较两者的价值，得出最大的价值存入现在的背包之中。

#include <iostream>
#include <vector>
#include <iomanip>
using namespace std;
void Init2Array(vector<vector<int> > &c, int row,int col)
{
	c.resize(row);
	for(int i = 0;i<row;++i)
	{
		c[i].resize(col,0);
	}
}
void Print2Array(vector<vector<int> > &c)
{
	int row = c.size();
	int col = c[0].size();
	for(int i = 0;i<row;++i)
	{
		for(int j = 0;j<col;++j)
		{
			cout<<setw(4)<<c[i][j];
		}
		cout<<endl;
	}
	cout<<endl;
}

// m(i,j) i == n => j>=W[n]? V[n]:0;
//        i < n
//                  j<W[i] => m(i+1,j)

int Kanpsack(int *W,int *V,int i,int n,int j,
			 vector<vector<int> > &m)
{
	if(i == n) //Kanpsack(W,V,1,n,c,m)
	{
		m[i][j] = j>=W[n]? V[n]:0;
	}else if(m[i][j] > 0) //m[1][10]   
	{
		return m[i][j];
	}else if(j < W[i])
	{
		m[i][j] =  Kanpsack(W,V,i+1,n,j,m);//m[2][10]
	}else
	{
		int maxv1 = Kanpsack(W,V,i+1,n,j,m);
		int maxv2 = Kanpsack(W,V,i+1,n,j-W[i],m) + V[i];
		m[i][j] = maxv1 > maxv2 ? maxv1:maxv2;
	}
	return m[i][j];
}
void TrackBack(int *W,vector<vector<int> >&m,int n,int c,bool *X)
{
	for(int i = 1;i<n;++i)
	{
		if(m[i][c] != m[i+1][c])
		{
			X[i] = true;
			c = c - W[i];
		}
	}
	if(m[n][c] != 0)
	{
		X[n] = true;
	}
}

int ResKanpsack(int *W,int *V,int i,int j,vector<vector<int> > &m)
{
	if(i == 1) 
	{
		m[i][j] = j >=W[i]? V[i]:0;
	}else if(m[i][j] > 0)
	{
		return m[i][j];
	}else if(j < W[i])
	{
		m[i][j] = ResKanpsack(W,V,i-1,j,m);
	}
	else
	{
		int maxv1 = ResKanpsack(W,V,i-1,j,m);
		int maxv2 = ResKanpsack(W,V,i-1,j-W[i],m)+V[i];
		m[i][j] = maxv1 > maxv2? maxv1:maxv2;
	}
	return m[i][j];
}

int NiceResKanpsack(int *W,int *V,int n,int c,
					vector<vector<int> > &m)
{
	for(int i = 0;i<=n;++i) m[i][0] = 0;
	for(int j = 0;j<=c;++j) m[0][j] = 0;
	for(int j = 1;j<=c; ++j)
	{
		m[1][j] = j >=W[1] ? V[1] : 0;
	}
	for(int i = 2;i<=n;++i)
	{
		for(int j = 1;j<=c;++j)
		{
			if(j < W[i])
			{
				m[i][j] = m[i-1][j];
			}else
			{
				m[i][j] = max(m[i-1][j],m[i-1][j-W[i]] + V[i]);
			}
		}
	}
	return m[n][c];
}

int main()
{
	const int n = 5;
	const int c = 10;
	int  W[n+1]={0,2,2,6,5,4};//重量
	///          0 1 2 3 4 5
	int  V[n+1]={0,3,6,5,4,6};//价值
	bool X[n+1]={0,0,0,0,0,0};
	vector<vector<int> > m;
	Init2Array(m,n+1,c+1);
	//int maxv = Kanpsack(W,V,1,n,c,m);

	//int maxv = ResKanpsack(W,V,n,c,m);
	int maxv = NiceResKanpsack(W,V,n,c,m);
	cout<<"maxv : "<<maxv<<endl;

	Print2Array(m);
	for(int i =1; i<=n; i++) {
		printf("%d ", X[i]);
	}
	printf("\n");
	TrackBack(W,m,n,c,X);
	for(int i =1; i<=n; i++) {
		printf("%d ", X[i]);
	}
	return 0;
}