被朋友要求帮忙写一个程序。主要核心是算法，归纳起来核心是背包算法。原来学的早忘了。上网搜吧。
背包算法（转贴） http://hi.baidu.com/wzra/blog/item/7827b1c353532654b319a811.html
/**
* 背包问题
* 背包问题是计算机科学里的经典问题。在最简单的形式中，包括试图将不同重量的数据项放到
* 背包中．以使背包最后达到指定的总重量。不需要把所有的选项都放入背包中。
* 举例来说，假设想要背包精确地承重20磅，并且有5个可以选择放入的数据项，它们的重量
* 依次为11磅、8磅、7磅、6磅和5磅。对于选择放入的数据项数量不大时，人类很善于通过观察
* 就可以解决这个问题。于是大概可以计算出只有8磅、7磅和5磅的数据项加在一起和为20磅。
* 如果想要计算机来解决这个问题，就需要给计算机更详细的指令。算法如下：
* 1．如果在这个过程中的任何时刻，选择的数据项的总和符合目标重量，工作就完成了。
* 2．从选择第一个数据项开始。剩余的数据项的加和必须符合背包的目标重量减去第一个数据
* 项的重量；这是一个新的目标重量。
* 3．逐个地试每种剩余数据顶组合的可能性。但是，注意并不需要去试所有的组合，因为只要
* 数据顶朗和大于目标重量的时候，就停止添加数据项。
* 4．如果设有组合合适的话，放弃第—‘个数据项，并且从第二个数据项开始再重复一边整个
* 过程。
* 5．继续从第三个数据项开始，如此下去直到你已经试过所有的组合，这时知道没有解决答案
* 。
* 在刚刚描述的这个例子中，从11开始。现在想要剩余的数据项和为9(20减去u)。对于9，
* 从很小的8开始。现在想要剩余的数据项和为1(9减去8)。从7开始，但是它大于L，于是尝
* 试6，然后试5*它们都太大了d现在已经试过了所有的数据项，所以知道包含8的任何组合
* 和都不可能为9。接着尝试7，于是现在开始找的目标为2(9减去7)。
*
*/
public class Beibao{
static int[] a=new int[5]; //背包重量
static int[] b=new int[5]; //结果数组
static int flag=0; //下一个候选项
static int bound=20; //总重量
static int totle=0; //每次选择后的总重量
public static void inserttry(int i,int leftbound,int t){
if(i<5&&leftbound<=totle){
if(a[i]<leftbound){
b[t++]=a[i];
totle=totle-a[i];
leftbound=leftbound-a[i];
i++;
inserttry(i,leftbound,t);
}
else if(a[i]>leftbound){
totle=totle-a[i];
i++;
inserttry(i,leftbound,t);
}
else {
b[t]=a[i];
return;
}
}
else {
leftbound=leftbound+b[--t];
for(int f=0;f<5;f++)
{
if (a[f]==b[t]) {flag=++f; break;}
}
b[t]=0;
totle=0;
for(int m=flag;m<5;m++)
{ totle+=a[m];
}
inserttry(flag,leftbound,t);
}
return;
}
public static void main(String[] args){
a[0]=11;
a[1]=8;
a[2]=6;
a[3]=7;
a[4]=5;
for(int i=0;i<5;i++) { b[i]=0;}
for(int i=0;i<5;i++) {
totle+=a[i];
}
inserttry(0,20,0);
for(int i=0;i<5;i++){
System.out.println(b[i]);
}
}
}
问题描述:
设U = {u1,u2,u3,ui}(一共有amount数量的物品)是一组准备放入背包中的物品.设背包的容量为size.
定义每个物品都具有两个属性weight和value.
我们要解决的问题就是计算在所选取的物品总重量不超过背包容量size的前提下使所选的物品总价值最大.
程序的设计:
设V[i, j]用来表示从前i项{u1ui}中取出来的装入体积为j的背包的最大价值.i的范围是从0到amount,j是从0到size.这样的话要 计算的值就是V[amount, size].V[0, j]对于所有的j的值都是0,因为这时候的包中没有物品.同时V[i, 0]的值也是0,因为没有物品可以放到size为0的背包里面.
所以有:
V[i, j] = 0 若i = 0 或 j = 0;
V[i, j] = V[i - 1, j] 若j < ui.weight;(当物品的重量大于背包承重时,就不把物品放在里面)
V[i, j] = max{V[i - 1, j], V[i - 1, j - ui.weight] + ui.value} 若i > 0并且j >= ui.weight;
现在就可用动态规划的方法运用上面的公式来填表求解了.
#include <stdio.h>
#define W 1000
#define N 1000
typedef struct data
{
int vaule;
int weight;
}goods;
int returnmax(int a, int b)
{
return (a > b ? a : b);
}
int KNAPSACK(goods *P, int a, int s)
{
int V[N][W];
int i,j,mv;
for(i = 0; i < a; i++)
V[i][0] = 0;
for(j = 0; j < s; j++)
V[0][j] = 0;
for(i = 1; i <= a; i++)
for(j = 1; j <= s; j++)
{
V[i][j] = V[i - 1][j];
if(P[i].weight <= j)
V[i][j] = returnmax(V[i][j],V[i - 1][j - P[i].weight] + P[i].vaule);
}
mv = V[a][s];
return mv;
}
int main()
{
int mostvalue,amount,size,i;
goods A[N];
printf("Input how much the goods have: ");
scanf("%d",&amount);
printf("Input the size of the bag: ");
scanf("%d",&size);
printf("Input the data of the goods: ");
for(i = 0; i < amount; i++)
scanf("%d %d",&A[i].vaule,&A[i].weight);
mostvalue = KNAPSACK(A,amount,size);
printf("%d",mostvalue);
return 0;
}
还有一种纯粹用数组解决的方案，避免了结构体的效率底下，思路是一样的
代码如下：
#include<iostream>
#define GOODNUM 5
using namespace std;
int main()
{
int good[GOODNUM][2]={{4,6},{5,2},{6,3},{7,7},{8,5}};//good[i][0]:size||good[i][1]:value
int i,j,size,weight;
int v[GOODNUM+1][1000];
cout<<"please input the bag's size"<<endl;
cin>>size;
for(i=0;i<=GOODNUM;i++)
v[i][0]=0;
for(i=0;i<=size;i++)
v[0][i]=0;
for(i=1;i<=GOODNUM;i++)
for(j=1;j<=size;j++){
v[i][j]=v[i-1][j];
if(good[i-1][0]<=j)
if((v[i-1][j-good[i-1][0]]+good[i-1][1])>v[i][j])
v[i][j]=v[i-1][j-good[i-1][0]]+good[i-1][1];
}
cout<<v[GOODNUM][size]<<endl;
}
背包算法（转贴） http://hi.baidu.com/wzra/blog/item/7827b1c353532654b319a811.html
/**
* 背包问题 * 背包问题是计算机科学里的经典问题。在最简单的形式中，包括试图将不同重量的数据项放到 * 背包中．以使背包最后达到指定的总重量。不需要把所有的选项都放入背包中。 * 举例来说，假设想要背包精确地承重20磅，并且有5个可以选择放入的数据项，它们的重量 * 依次为11磅、8磅、7磅、6磅和5磅。对于选择放入的数据项数量不大时，人类很善于通过观察 * 就可以解决这个问题。于是大概可以计算出只有8磅、7磅和5磅的数据项加在一起和为20磅。 * 如果想要计算机来解决这个问题，就需要给计算机更详细的指令。算法如下： * 1．如果在这个过程中的任何时刻，选择的数据项的总和符合目标重量，工作就完成了。 * 2．从选择第一个数据项开始。剩余的数据项的加和必须符合背包的目标重量减去第一个数据 * 项的重量；这是一个新的目标重量。 * 3．逐个地试每种剩余数据顶组合的可能性。但是，注意并不需要去试所有的组合，因为只要 * 数据顶朗和大于目标重量的时候，就停止添加数据项。 * 4．如果设有组合合适的话，放弃第—‘个数据项，并且从第二个数据项开始再重复一边整个 * 过程。 * 5．继续从第三个数据项开始，如此下去直到你已经试过所有的组合，这时知道没有解决答案 * 。 * 在刚刚描述的这个例子中，从11开始。现在想要剩余的数据项和为9(20减去u)。对于9， * 从很小的8开始。现在想要剩余的数据项和为1(9减去8)。从7开始，但是它大于L，于是尝 * 试6，然后试5*它们都太大了d现在已经试过了所有的数据项，所以知道包含8的任何组合 * 和都不可能为9。接着尝试7，于是现在开始找的目标为2(9减去7)。 *
*/public class Beibao{ static int[] a=new int[5]; //背包重量 static int[] b=new int[5]; //结果数组 static int flag=0; //下一个候选项 static int bound=20; //总重量 static int totle=0; //每次选择后的总重量 
public static void inserttry(int i,int leftbound,int t){
if(i<5&&leftbound<=totle){ if(a[i]<leftbound){ b[t++]=a[i]; totle=totle-a[i]; leftbound=leftbound-a[i]; i++; inserttry(i,leftbound,t);
} else if(a[i]>leftbound){ totle=totle-a[i]; i++; inserttry(i,leftbound,t); } else { b[t]=a[i]; return; } } else { leftbound=leftbound+b[--t]; for(int f=0;f<5;f++) { if (a[f]==b[t]) {flag=++f; break;} } b[t]=0; totle=0; for(int m=flag;m<5;m++) { totle+=a[m]; } inserttry(flag,leftbound,t); } return; } public static void main(String[] args){ a[0]=11; a[1]=8; a[2]=6; a[3]=7; a[4]=5; for(int i=0;i<5;i++) { b[i]=0;} for(int i=0;i<5;i++) { totle+=a[i]; } inserttry(0,20,0); for(int i=0;i<5;i++){ System.out.println(b[i]); } }} 
据说是Java的。我看和C#也没什么两样。不过我要改写成VB的因为打算用在Excel里。
那个链接里还有一些相关文章。也不错。
我怎么觉得这算法是穷举法呢？
这还有一个动态规划的算法
动态规划/贪心算法----0/1背包问题AND普通背包问题
http://blog.csdn.net/simon_ghost/archive/2006/11/20/1398157.aspx
明天再详细比较一下。
看懂了这个算法，这个是动态规划的，时间复杂度0（n）。
http://www.diybl.com/course/3_program/c++/cppjs/20071023/79603.html
问题描述:设U = {u1,u2,u3,
ui}(一共有amount数量的物品)是一组准备放入背包中的物品.设背包的容量为size.定义每个物品都具有两个属性weight和value.我们要解决的问题就是计算在所选取的物品总重量不超过背包容量size的前提下使所选的物品总价值最大.程序的设计:设V[i, j]用来表示从前i项{u1ui}中取出来的装入体积为j的背包的最大价值.i的范围是从0到amount,j是从0到size.这样的话要 计算的值就是V[amount, size].V[0, j]对于所有的j的值都是0,因为这时候的包中没有物品.同时V[i, 0]的值也是0,因为没有物品可以放到size为0的背包里面.所以有:V[i, j] = 0 若i = 0 或 j = 0;V[i, j] = V[i - 1, j] 若j < ui.weight;(当物品的重量大于背包承重时,就不把物品放在里面)V[i, j] = max{V[i - 1, j], V[i - 1, j - ui.weight] + ui.value} 若i > 0并且j >= ui.weight; 现在就可用动态规划的方法运用上面的公式来填表求解了.#include <stdio.h>#define W 1000#define N 1000typedef struct data{ int vaule; int weight;}goods;int returnmax(int a, int b){ return (a > b ? a : b);}int KNAPSACK(goods *P, int a, int s){ int V[N][W]; int i,j,mv; for(i = 0; i < a; i++) V[i][0] = 0; for(j = 0; j < s; j++) V[0][j] = 0; for(i = 1; i <= a; i++) for(j = 1; j <= s; j++) { V[i][j] = V[i - 1][j]; if(P[i].weight <= j) V[i][j] = returnmax(V[i][j],V[i - 1][j - P[i].weight] + P[i].vaule); } mv = V[a][s]; return mv;}int main(){ int mostvalue,amount,size,i; goods A[N]; printf("Input how much the goods have: "); scanf("%d",&amount); printf("Input the size of the bag: "); scanf("%d",&size); printf("Input the data of the goods: "); for(i = 0; i < amount; i++) scanf("%d %d",&A[i].vaule,&A[i].weight); mostvalue = KNAPSACK(A,amount,size); printf("%d",mostvalue); return 0;} 还有一种纯粹用数组解决的方案，避免了结构体的效率底下，思路是一样的代码如下：#include<iostream>#define GOODNUM 5using namespace std;int main(){ int good[GOODNUM][2]={{4,6},{5,2},{6,3},{7,7},{8,5}};//good[i][0]:size||good[i][1]:value int i,j,size,weight; int v[GOODNUM+1][1000]; cout<<"please input the bag's size"<<endl; cin>>size; for(i=0;i<=GOODNUM;i++) v[i][0]=0; for(i=0;i<=size;i++) v[0][i]=0; for(i=1;i<=GOODNUM;i++) for(j=1;j<=size;j++){ v[i][j]=v[i-1][j]; if(good[i-1][0]<=j) if((v[i-1][j-good[i-1][0]]+good[i-1][1])>v[i][j]) v[i][j]=v[i-1][j-good[i-1][0]]+good[i-1][1]; } cout<<v[GOODNUM][size]<<endl;}
来源：https://www.cnblogs.com/renmin/archive/2008/04/08/1142754.html