01背包问题

01背包问题

基本思想：

动态规划算法通常用于求解具有某种最优性质的问题。在这类问题中，可能会有许多可行解。每一个解都对应于一个值，我们希望找到具有最优值的解。动态规划算法与分治法类似，其基本思想也是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。与分治法不同的是，适合于用动态规划求解的问题，经分解得到子问题往往不是互相独立的（即下一个子阶段的求解是建立在上一个子阶段的解的基础上，进行进一步的求解）。若用分治法来解这类问题，则分解得到的子问题数目太多，有些子问题被重复计算了很多次。如果我们能够保存已解决的子问题的答案，而在需要时再找出已求得的答案，这样就可以避免大量的重复计算，节省时间。我们可以用一个表来记录所有已解的子问题的答案。不管该子问题以后是否被用到，只要它被计算过，就将其结果填入表中。这就是动态规划法的基本思路。具体的动态规划算法多种多样，但它们具有相同的填表格式。

应用场景：

适用动态规划的问题必须满足最优化原理、无后效性和重叠性。
1、最优化原理（最优子结构性质） 最优化原理可这样阐述：一个最优化策略具有这样的性质，不论过去状态和决策如何，对前面的决策所形成的状态而言，余下的诸决策必须构成最优策略。简而言之，一个最优化策略的子策略总是最优的。一个问题满足最优化原理又称其具有最优子结构性质。

2、无后效性 将各阶段按照一定的次序排列好之后，对于某个给定的阶段状态，它以前各阶段的状态无法直接影响它未来的决策，而只能通过当前的这个状态。换句话说，每个状态都是过去历史的一个完整总结。这就是无后向性，又称为无后效性。

3、子问题的重叠性 动态规划将原来具有指数级时间复杂度的搜索算法改进成了具有多项式时间复杂度的算法。其中的关键在于解决冗余，这是动态规划算法的根本目的。动态规划实质上是一种以空间换时间的技术，它在实现的过程中，不得不存储产生过程中的各种状态，所以它的空间复杂度要大于其它的算法。

下面是一个关于 0-1背包问题 的动态规划思想PPT截图：

问题描述：
　　给定n种物品和一背包。物品i的重量是wi，其价值为vi，背包的容量为C。问应如何选择装入背包的物品，使得装入背包中物品的总价值最大?

对于一种物品，要么装入背包，要么不装。所以对于一种物品的装入状态可以取0和1.我们设物品i的装入状态为xi,xi∈ (0,1)，此问题称为0-1背包问题。

　　数据：物品个数n=5,物品重量w
={0，2，2，6，5，4},物品价值V
={0，6，3，5，4，6},
（第0位，置为0，不参与计算，只是便于与后面的下标进行统一，无特别用处，也可不这么处理。）总重量c=10。背包的最大容量为10，那么在设置数组m大小时，可以设行列值为6和11，那么，对于m(i,j)就表示可选物品为i…n，背包容量为j(总重量)时背包中所放物品的最大价值。

最优值分析过程如下：

　　当背包为空时，首先分析将物品n放入背包，即在总重量分别为0到10时，如何放置物品n使总价值最大。

　　对于m[5][j]，当j<w[5]时，物品5不能放入背包中，此时背包的价值为0。当j>=w[5]时，物品5可以放入背包，此时背包的价值为v[5]。得到结果如下表：



　　在物品5的基础上分析物品4，

　　当j<w[4]时，物品4不能放入，此时背包的最大价值为m[4+1][j]；即m[4][0..4]=m[5][0..4]

　　当j>=w[4]时，物品4要么放入要么不放入。当物品4放入背包后，对于物品4+1到n，能达到的最大价值为m[4+1][j-w[4]]+v[4]，故此时能达到的最大价值为m[4+1][j-w[4]]+v[4]

　　当物品4不放入背包时，能达到的最大价值为m[4+1][j]。最后比较放入与不放入情况下，两者的最大值取其大者，分析结果如下：



　　由前面分析过程得m[i][j]的递归过程如下：

　　


　　最终得到如下结果：



　　

构造最优解

　　最优解的构造可根据C列的数据来构造最优解，构造时从第一个物品开始。从i=1,j=c即m[1][c]开始。　　

　　1、对于m[i][j]，如果m[i][j]==m[i+1][j]，则物品i没有装入背包，否则物品i装入背包；

　 2、为了确定后继即物品i+1，应该寻找新的j值作为参照。如果物品i已放入背包，则j=j-w[i]；如果物品i未放入背包，则j=j。

　　3、重复上述两步判断后续物品i到物品n-1是否放入背包。

　　4、对于物品n，直接通过m
[j]是否为0来判断物品n是否放入背包。



　　参考：五种常用算法之三：动态规划

　　

#include<iostream>
#include<stack>
#include<vector>

using namespace std;

stack<int> KnapSack(int c,vector<int> w,vector<int> v,int &max_m)
{
vector<vector <int> > m(w.size(),vector<int>(c+1));
stack<int> res;
int i,j;

max_m=0;
for(j=0;j<c+1;j++) //对于m
[j]，
if(j<w[w.size()-1])
m[w.size()-1][j]=0;  //当j<w
时，物品n不能放入背包中，此时背包的价值为0。
else
m[w.size()-1][j]=v[v.size()-1];  //当j>=w
时，物品n可以放入背包，此时背包的价值为v

for(i=w.size()-2;i>=0;i--) //对于m[i][j]，
{
for(j=0;j<c+1;j++)
if(j<w[i])          //当j<w[i]时，物品i不能放入背包中，此时背包的价值为m[i+1][j]。
m[i][j]=m[i+1][j];
else                //当j>=w[i]时，物品n可以放入背包
{
int m1=m[i+1][j];  //当物品i不放入背包时，能达到的最大价值为m[i+1][j]
int m2=m[i+1][j-w[i]]+v[i];  //当物品i放入背包后，对于物品i+1到n，能达到的最大价值为m[i+1][j-w[i]]+v[i]
m[i][j]=m1>m2?m1:m2;         //两者取其大者
}
}
/*    cout << "最优值矩阵:"<<endl;
for(i=0;i<w.size();i++)
{
for(j=0;j<c+1;j++)
cout<<m[i][j]<<" ";
cout <<endl;
}
cout <<endl;
*/
j=c;
for(i=0;i<w.size()-1;i++)
{
if(m[i][j]!=m[i+1][j])
{
res.push(i+1);
max_m+=v[i];
j=j-w[i];
}
}
if(m[w.size()-1][j]!=0)
{
res.push(w.size());
max_m+=v[w.size()-1];
}

return res;
}

int main()
{
vector<int> weight;
vector<int> value;
stack<int>  result;
int max_weight;
int tmp;
int result_m=0;

cout<< "输入背包最大容量"<<endl;
cin >> max_weight;
cout <<"输入物品重量,以0结束"<<endl;

while(1)
{
cin>>tmp;
if(tmp!=0)
weight.push_back(tmp);
else
break;
}
cout <<"物品重量: "<<endl;
for(int i=0;i<weight.size();i++)
cout <<weight[i]<<" ";
cout << endl;
cout <<"输入物品权重,以0结束"<<endl;
while(1)
{
cin>>tmp;
if(tmp!=0)
value.push_back(tmp);
else
break;
}

cout <<"物品权重: "<<endl;
for(int i=0;i<value.size();i++)
cout <<value[i]<<" ";
cout << endl;

result=KnapSack(max_weight,weight,value,result_m);

cout <<"放入背包的物品为："<<endl;
while(!result.empty())
{
cout <<result.top()<<" ";
result.pop();
}
cout <<endl;
cout<<"背包最大价值为："<<result_m<<endl;

return 0;
}

分类: 五大算法