【问题描述】
“背包题目”的基本描述是：有一个背包，能盛放的物品总重量为S,设有N件物品，其重量分别为w1，w2，…，wn，希望从N件物品中选择若干物品，所选物品的重量之和恰能放进该背包，即所选物品的重量之和即是S。递归和非递归解法都能，试非递归算法求得“背包题目”的一组解
【算法分析】
1.此程序是得到问题的所有解；
2.本题只对背包有重量约束；
3.算法思想（暴力枚举）
1）初始化flag数组，数组长度为背包数目 n，数组为全 0 序列，0,1表示是否添加第 i 个 背包，初始状态下一个背包都不添加；
2）添加背包的排列的可能性为2^n种，n为背包的数目：
a.循环中 flag 每次遇到1则补零进位，遇到0则补一并退出对 flag 的循环更新；
b.将添加背包的序列号写入临时数组，通过判断总重与 S 的关系决定是否打印输出；
【屌丝源码】
// ---------------------------------------------------
// 注1: 一般要求一个解，此程序是得到所有解
// 注2: 只对背包有重量约束，此程序更易理解
// ---------------------------------------------------
#include <iostream>
using namespace std;
// 物品总数
const int N_ITEM = 5;
// 背包能装的重量
const int BAG = 15;
// 初始化每个物品的重量
int item[N_ITEM] = {2, 3, 5, 7, 8};
// 标记数组
int flag[N_ITEM] = {0, 0, 0, 0, 0};
// 结果计数器
int resultCount = 0;
// 打印结果
void Print();
int main()
{
// 打印已知条件
cout << "BAG Weight:" << BAG << endl;
cout << "Item Number:" << N_ITEM << endl;
for (int i=0; i!=N_ITEM; i++)
{
cout << "Item." << i+1 << " W=" << item[i] << "\t";
}
cout << endl;
unsigned int count = 0;
unsigned int all_count = 1;
for (int i=0; i!=N_ITEM; i++)
{
all_count *= 2;//all_count记录可能解的个数
}
while (1)
{
// 模拟递归...列举所有flag数组可能
// 其实就这个for循环是关键
for (int i=0; i!=N_ITEM; i++)
{
if ( 0 == flag[i] )
{
flag[i] = 1;
continue;
}
else
{
flag[i] = 0;
break;
}
}
// 本次重量,初始化0
int temp = 0;
// 按标记计算所有选中物品重量和
for (int i=0; i!=N_ITEM; i++)
{
if ( 1 == flag[i] )
{
temp += item[i];
}
}
// 满足背包重量就打印
if ( temp == BAG )
{
resultCount++;
Print();
}
// 如果遍历了所有情况就break掉while(1)循环
count++;
if (count == all_count)
{
break;
}
}
return 0;
}
void Print()
{
cout << "Result " << resultCount << endl;
for (int i=0; i!=N_ITEM; i++)
{
if ( 1 == flag[i] )
{
cout << "Item." << i+1 << " Weight:" << item[i] << "\t";
}
}
cout << endl;
}
只求一个解算法思想——括号算法思想。
详见：LeetCode 之 Valid Palindrome（字符串）
详址：http://blog.csdn.net/u013630349/article/details/46998327
代码
vector<int> knapsack(int *w, int N, int S){
stack<int> stk;
int weight = 0;
int i = 0;
bool solvable = false;
while( weight != S && i < N){
weight += w[i];
if( weight < S){
stk.push(i);
}
else
if( weight == S){
solvable = true;
break;
}
else{
i = stk.top();
stk.pop();
}
i++;
}
vector<int> ret;
if( solvable == false)
return ret;
while( !stk.empty() ){
ret.push_back(stk.top());
stk.pop();
}
return ret;
}
【迭代解的思想与算法】
全部可能解的算法思想——树的“深搜”
详址：http://blog.csdn.net/u013630349/article/details/47121697
代码
// 现采用迭代方式实现，之后在对非迭代方式处理
// 算法思想：从根节点 O 出发，经过n个节点到达满二叉树叶子节点
// 第i-1层节点下的左右两个孩子有，左节点表示添加Wi个背包，右节点表示不添加Wi个
// 在节点到达重量S的时候录入容器
Class Solution
{
public:
vector<vector<int>> Get_Res(int n,int S,vector<int> &w){
vector<vector<int>> res;
stack<int> path;
myfun(path,res,S,0,w,0,n);
return res;
}
// path 表示添加的路径；
// res 表示路径集合；
// wei 当前路径下的重量
// Level 当前层数
// 初态下 Level和wei 都是 0
void myfun(stack<int> &path,vector<vector<int>> &res,int S,int wei,vector<int> &w,int Level,int n)
{
if(Level>=n)
{
if(S==wei)
res.push_back(path);
return;
}
if(wei==S)
{
res.push(path);
}
if(wei>S)
{
return;
}
myfun(path,res,S,wei,w,Level+1,n);
path.push(Level);
wei = wei+w[Level];
myfun(path,res,S,wei,w,Level+1,n);
path.pop();
wei = wei-w[Level];
}
}； 【小结】
1.可以通过全可能性列举，确定循环次数；
2.可以通过标志维数组，确定路径的选择；
3.单一解，括号算法是优先考虑的选择；
3.在迭代许可的条件下，针对全部解的问题，树的“深搜”算法，是很好的选择。
二、解决方法：
1、贪心算法：贪心算法基于的思想是每一次选择都作当前最好的选择，这样最后的结果虽然不一定是最优解，但是也不会比最优解差很多。
举个例子说明可能好懂一些：一帮基友去聚餐，菜是一份一份上的，我每一次夹菜都只夹牛肉/海鲜吃，可能到最后我吃的牛肉/海鲜很多，但不一定代表我吃掉的东西的总价值最高，但是相对来说价值也很高了～
换句话说，对于贪心算法，其核心在于设定一个标准让我们去贪。回到这个问题，这个标准就有三种设法了：1、价值最高的先装进背包；2、重量最低的先装进包；3、性价比（价值和重量的比值）最高的先装进背包。我在这里用的是第三种方法，用快排作了排序。
在装的过程中要注意的就是，当前物品能不能放进背包。这个是需要考虑的。因为背包问题也有好几种，如：0-1背包问题（每种物品只能拿一次）、完全背包问题（每种物品都能拿无限次）、多重背包问题（每种物品都有一定的数量可以拿）。所以在不同情况下贪心算法的一些细节设计也是不一样的，这个需要自己考虑。
2、动态规划算法：贯穿动态规划算法的就是状态和状态转移方程这两个东西，而要得到这两个东西需要我们把我们的问题分解为更小的子问题，通过分析子问题去获得。这个我在LIS问题上也讲过（数据结构与算法学习之路：LIS——最长递增序列的动态规划算法和二分思想算法）
那么回到我们这个问题，由于每次装东西进背包，我们只考虑能否装进，以及是否当前状态下的最优选择，也就是说，我们需要用背包的容量去设计一个数组，存储每一单位个容量的最大价值是多少，以此类推，获得背包容量下的最大价值是多少。这样说可能说不清楚，看看下面的代码吧～
版权声明：本文为博主原创文章，未经博主允许不得转载。
原文地址：http://blog.csdn.net/u013630349/article/details/47206963
