01背包问题 C++ 动态规划学习

问题描述：
共有n个物品，第i个物品的质量为wei[i]，第i个物品的价值为value[i],现有一个可容最大质量为V的背包，问：如何选取物品放入背包，使背包的总价值最大。
样例输入：
5 8
3 5 1 2 2
4 5 2 1 3
样例输出：
10
样例解析：
0号2号3号4号背包价值和最大，为10
即4+2+1+3=10
输入样例解释
输入第一行：含两个整数，分别表示n个物品，背包最大质量
输入第二行：含n个整数，分别表示这n个物品的质量
输入第三行：含n个整数，分别表示这n个物品的价值

暴力递归：

这种思路比较简单，对于每个物品只有取或者不取两种操作
只需要通过递归对所有的情况都进行计算并刷新最大价值即可
时间复杂度为O（2^n）
我的代码示意如下：

//01背包问题 递归 暴力 
/*
在每个背包都有两个选择 
	选： 
	不选：超过总重量时一定不能选 
	 
样例输入： 
5 8
3 5 1 2 2
4 5 2 1 3
样例输出：
10 
样例解析：
0号2号3号4号背包价值和最大，为10 
即4+2+1+3=10 
*/

#include<iostream>
using namespace std;
int maxWei=0,num=0,maxValue=0;//使用全局变量 
void GetMaxValue(int wei[],int value[],int i,int tempMaxWei,int tempMaxValue){//i表示正对第i个物品操作 
	if( i == num ){//递归终止条件 
		maxValue>tempMaxValue ? maxValue=maxValue:maxValue=tempMaxValue;
		//刷新最大价值 
		return;
	}
	else{
		if(tempMaxWei+wei[i]<=maxWei){//如果总重量不超过上限 
			GetMaxValue(wei,value,i+1,tempMaxWei+wei[i],tempMaxValue+value[i]);
			//选上第i个物品  刷新当前质量    刷新当前价值
		}
		//这里注意if else的关系 
		GetMaxValue(wei,value,i+1,tempMaxWei,tempMaxValue);
		//不选上第i个物品 
	}
}

int main(){
	cin>>num>>maxWei;
	int wei[num],value[num];
	for(int i=0;i<num;i++){//数据读入 
		cin>>wei[i];
	}
	for(int i=0;i<num;i++){//数据读入 
		cin>>value[i];
	}
	GetMaxValue(wei,value,0,0,0);//函数调用 
	cout<<maxValue; 
	return 0;
} 

动态规划：

设计状态转移方程：
以dp[i][j]表示到第i个物品时背包中质量为j的最大价值
则dp[i][j]=max(dp[i-1][j],dp[i-1][j-wei[i]]+value[i]);
外循环是物品数，内循环是最大质量
时间复杂度为O（nV）

/*
样例输入1：
5 20
5 25 12 10 15
10 40 8 10 2
样例输出1：
20 

样例输入2：
4 7
1 3 4 5
1 4 5 7
样例输出2：
9
*/

#include<iostream>
#include<algorithm>
using namespace std;

int main(){
	int num,maxWei;
	cin>>num>>maxWei;
	int wei[num+1],value[num+1],dp[num+1][maxWei+1];//这样下标即位真实质量或价值 便于理解 
	
	for(int i=1;i<=num;i++){//数据读入 
		cin>>wei[i];
	}
	for(int i=1;i<=num;i++){//数据读入 
		cin>>value[i];
	}
	for(int i=0;i<=maxWei;i++){
		dp[1][i]=0;dp[0][i]=0;
	}
	//dp[1][wei[1]]=value[1];//初始化边界情况 
	int maxValue=value[1];
	
	for(int i=1;i<=num;i++){
		for(int j=0;j<=maxWei;j++){
			if(j-wei[i]>=0){   //防止越界 
				dp[i][j]=max(dp[i-1][j],dp[i-1][j-wei[i]]+value[i]);//注意下标 容易出错 
			}
			else{
				dp[i][j]=dp[i-1][j]; 
			}
			maxValue=max(maxValue,dp[i][j]);//刷新获取最大价值 
		}
	}
	cout<<maxValue;
	return 0;
} 

滚动数组

经过动态规划的全过程，可以发现当i-1的数据用完后就不再使用。对此可以进行空间上的优化：即滚动数组

只需要一维数组即可完成该过程，再第i次的过程中覆盖第i-1次的数据

动态转移方程：
dp[j]=max(dp[j],dp[ j-wei[i] ]+value[i]);

且第二重循环必须是逆序，否则将会使用到第i轮的数据来计算第i轮的结果，这在完全背包问题的滚动数组时可以更好的理解

/*
滚动数组
*/
#include<iostream>
#include<algorithm>
using namespace std;

int main(){
	int num,maxWei;
	cin>>num>>maxWei;
	int wei[num+1],value[num+1],dp[maxWei+1];
	for(int i=1;i<=num;i++){//数据读入 
		cin>>wei[i];
	}
	for(int i=1;i<=num;i++){//数据读入 
		cin>>value[i];
	}
	for(int j=maxWei;j>=0;j--){
		dp[j]=0;//初始化 
	}
	int maxValue=0;
	for(int i=1;i<=num;i++){
		for(int j=maxWei;j>=wei[i];j--){
			if(j-wei[i] >= 0){
				dp[j]=max(dp[j],dp[j-wei[i]]+value[i]);//状态转移方程 + 滚动数组
			}
			maxValue=max(maxValue,dp[j]);//刷新最大价值 
		}
	}
	cout<<maxValue;
	return 0;
}

回溯问题：

如何获取所拿背包？
采用回溯方法，根据动态转移方程：
只要dp[i][j]==dp[i-1][j];这个物品就未拿，反之即拿了该物品；
注意：
可能出现多种情况可以获取最大价值

//这里的key即位获得最大价值时的背包质量，也可在dp时同步获取
	int key=0;//找最大价值进行回溯   提示：这里可能出现多组，可用数组，向量等容器储存 我这里只回溯了一种情况
	for(;key<=maxWei;key++){
		if(dp[num][key] == maxValue){
			break;
		}
	}
	//因为这里是逆序回溯，结果是先进后出自然联想到了栈 
	stack<int>bag;
	for(int i=num;i>=1;i--){
		if(dp[i][key] != dp[i-1][key]){//即选中该物品 
			key=key-wei[i];//刷新key值 
			bag.push(i);//放入栈中 
		}
	}
	while(!bag.empty()){//只要栈未空就继续 
		cout<<bag.top()<<" ";//逆序输出 
		bag.pop();//顶出最顶上的元素 
	}

参考书籍：《算法笔记》