【编程】背包问题

被朋友要求帮忙写一个程序。主要核心是算法，归纳起来核心是背包算法。原来学的早忘了。上网搜吧。
背包算法（转贴） 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 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;
}