经典算法详解 之 背包算法



算法 string class 优化 c

          背包问题(Knapsackproblem)是一种组合优化的NP完全问题。问题可以描述为:给定一组物品,每种物品都有自己的重量和价格,在限定的总重量内,我们如何选择,才能使得物品的总价格最高。这个问题涉及到了两个条件:一是物品总的大小小于或等于背包的大小,二是物品总的价值要尽量大。

如果我们用子问题定义状态来描述的话可以这样解释

f[i][v]表示前i件物品恰放入一个容量为v的背包可以获得的最大价值。用公式表示:


                       f[i][v]=max{f[i-1][v],f[i-1][v-c[i]]+w[i]} f[v]=max{f[v],f[v-c[i]]+w[i]}


    具体的解释可以理解为将前i件物品放入容量为v的背包中,只考虑第i件物品的策略(放或不放),那么就可以转化为一个只涉及前i-1件物品和第i件物品的问题。如果不放第i件物品,那么问题就转化为“前i-1件物品放入容量为v的背包中”,价值为f[i-1][v];如果放第i件物品,那么问题就转化为“前i-1件物品放入剩下的容量为v-c[i]的背包中”,此时能获得的最大价值就是f[i-1][v-c[i]]再加上通过放入第i件物品获得的价值w[i]。v表示背包的最大容量,c[i]表示第i件物品的大小,w[i]表示第i件物品的价值)


算法如下:

[plain]  view plain copy print ?
  1. class Fruit{  
  2.     private String name;  
  3.     private int size;  
  4.     private int price;  
  5.       
  6.     public Fruit(String name,int size,int price){  
  7.         this.name=name;  
  8.         this.size=size;  
  9.         this.price=price;  
  10.     }  
  11.     public String getName(){  
  12.         return name;  
  13.     }  
  14.     public int getPrice(){  
  15.         return price;  
  16.     }  
  17.     public int getSize(){  
  18.         return size;  
  19.     }  
  20. }  
  21.   
  22. public class Knapsack{  
  23.     public static void main(String[] args){  
  24.         final int MAX=8;  
  25.         final int MIN=1;  
  26.         int[] item=new int[MAX+1];  
  27.         int[] value=new int[MAX+1];  
  28.         Fruit fruits[]={  
  29.             new Fruit("李子",4,4500),  
  30.             new Fruit("苹果",5,5700),  
  31.             new Fruit("橘子",2,2250),  
  32.             new Fruit("草莓",1,1100),  
  33.             new Fruit("甜瓜",6,6700)  
  34.         };  
  35.         for(int i=0;i<fruits.length;i++){  
  36.             for(int s=fruits[i].getSize();s<=MAX;s++){//s表示现在背包的大小  
  37.                 int p=s-fruits[i].getSize();//表示每次增加单位背包空间,背包所剩的空间  
  38.                 int newvalue=value[p]+fruits[i].getPrice();//value[p]表示增加的背包空间可以增加的价值,fruits[i].getprice()表示原有的背包的价值  
  39.                 if(newvalue>value[s]){//现有的价值是否大于背包为s时的价值  
  40.                     value[s]=newvalue;  
  41.                     item[s]=i;//将当前的水果项添加到背包的物品中  
  42.                 }  
  43.             }  
  44.         }  
  45.         System.out.println("物品\t价格");  
  46.         for(int i=MAX;i>MIN;i=i-fruits[item[i]].getSize()){  
  47.             System.out.println(fruits[item[i]].getName()+  
  48.                 "\t"+fruits[item[i]].getPrice());  
  49.         }  
  50.         System.out.println("合计\t"+value[MAX]);  
  51.     }  
  52. }  

程序运行的过程如下:

 

i=0时放入李子

背包负重

1

2

3

4

5

6

7

8

s

4

5

6

7

8

p

0

1

2

3

4

value

0

0

0

4500

4500

4500

4500

9000

item

0

0

0

0

0

i=1时放入苹果

背包负重

1

2

3

4

5

6

7

8

s

5

6

7

8

p

0

1

2

3

value

0

0

0

4500

5700

5700

5700

9000

item

0

1

1

1

0

i=2放入橘子

背包负重

1

2

3

4

5

6

7

8

s

2

3

4

5

6

7

8

p

0

1

2

3

4

5

6

value

0

2250

2250

4500

5700

6750

7950

9000

item

2

2

0

1

2

2

0

i=3放入草莓

背包负重

1

2

3

4

5

6

7

8

s

1

2

3

4

5

6

7

8

p

0

1

2

3

4

5

6

7

value

1100

2250

3350

4500

5700

6800

7950

9050

item

3

2

3

0

1

3

2

3

i=4放入甜瓜

背包负重

1

2

3

4

5

6

7

8

s

6

7

8

p

0

1

2

value

1100

2250

3350

4500

5700

6800

7950

9050

item

3

2

3

0

1

3

2

3

 

    由最后一个表格可以知道,在背包负重8的时候,最多得到价值9050的水果,这个时候可以得到装入的水果是3号水果草莓,那么剩下的(8-1=7)个大小空间,可以知到为2号水果也就是橘子,同理下一步可以知道放入的水果是1号水果苹果。此时获得的最优解的价值就是9050,放入的水果是草莓、橘子和苹果。

算法 string class 优化 c

          背包问题(Knapsackproblem)是一种组合优化的NP完全问题。问题可以描述为:给定一组物品,每种物品都有自己的重量和价格,在限定的总重量内,我们如何选择,才能使得物品的总价格最高。这个问题涉及到了两个条件:一是物品总的大小小于或等于背包的大小,二是物品总的价值要尽量大。

如果我们用子问题定义状态来描述的话可以这样解释

f[i][v]表示前i件物品恰放入一个容量为v的背包可以获得的最大价值。用公式表示:


                       f[i][v]=max{f[i-1][v],f[i-1][v-c[i]]+w[i]} f[v]=max{f[v],f[v-c[i]]+w[i]}


    具体的解释可以理解为将前i件物品放入容量为v的背包中,只考虑第i件物品的策略(放或不放),那么就可以转化为一个只涉及前i-1件物品和第i件物品的问题。如果不放第i件物品,那么问题就转化为“前i-1件物品放入容量为v的背包中”,价值为f[i-1][v];如果放第i件物品,那么问题就转化为“前i-1件物品放入剩下的容量为v-c[i]的背包中”,此时能获得的最大价值就是f[i-1][v-c[i]]再加上通过放入第i件物品获得的价值w[i]。v表示背包的最大容量,c[i]表示第i件物品的大小,w[i]表示第i件物品的价值)


算法如下:

[plain]  view plain copy print ?
  1. class Fruit{  
  2.     private String name;  
  3.     private int size;  
  4.     private int price;  
  5.       
  6.     public Fruit(String name,int size,int price){  
  7.         this.name=name;  
  8.         this.size=size;  
  9.         this.price=price;  
  10.     }  
  11.     public String getName(){  
  12.         return name;  
  13.     }  
  14.     public int getPrice(){  
  15.         return price;  
  16.     }  
  17.     public int getSize(){  
  18.         return size;  
  19.     }  
  20. }  
  21.   
  22. public class Knapsack{  
  23.     public static void main(String[] args){  
  24.         final int MAX=8;  
  25.         final int MIN=1;  
  26.         int[] item=new int[MAX+1];  
  27.         int[] value=new int[MAX+1];  
  28.         Fruit fruits[]={  
  29.             new Fruit("李子",4,4500),  
  30.             new Fruit("苹果",5,5700),  
  31.             new Fruit("橘子",2,2250),  
  32.             new Fruit("草莓",1,1100),  
  33.             new Fruit("甜瓜",6,6700)  
  34.         };  
  35.         for(int i=0;i<fruits.length;i++){  
  36.             for(int s=fruits[i].getSize();s<=MAX;s++){//s表示现在背包的大小  
  37.                 int p=s-fruits[i].getSize();//表示每次增加单位背包空间,背包所剩的空间  
  38.                 int newvalue=value[p]+fruits[i].getPrice();//value[p]表示增加的背包空间可以增加的价值,fruits[i].getprice()表示原有的背包的价值  
  39.                 if(newvalue>value[s]){//现有的价值是否大于背包为s时的价值  
  40.                     value[s]=newvalue;  
  41.                     item[s]=i;//将当前的水果项添加到背包的物品中  
  42.                 }  
  43.             }  
  44.         }  
  45.         System.out.println("物品\t价格");  
  46.         for(int i=MAX;i>MIN;i=i-fruits[item[i]].getSize()){  
  47.             System.out.println(fruits[item[i]].getName()+  
  48.                 "\t"+fruits[item[i]].getPrice());  
  49.         }  
  50.         System.out.println("合计\t"+value[MAX]);  
  51.     }  
  52. }  

程序运行的过程如下:

 

i=0时放入李子

背包负重

1

2

3

4

5

6

7

8

s

4

5

6

7

8

p

0

1

2

3

4

value

0

0

0

4500

4500

4500

4500

9000

item

0

0

0

0

0

i=1时放入苹果

背包负重

1

2

3

4

5

6

7

8

s

5

6

7

8

p

0

1

2

3

value

0

0

0

4500

5700

5700

5700

9000

item

0

1

1

1

0

i=2放入橘子

背包负重

1

2

3

4

5

6

7

8

s

2

3

4

5

6

7

8

p

0

1

2

3

4

5

6

value

0

2250

2250

4500

5700

6750

7950

9000

item

2

2

0

1

2

2

0

i=3放入草莓

背包负重

1

2

3

4

5

6

7

8

s

1

2

3

4

5

6

7

8

p

0

1

2

3

4

5

6

7

value

1100

2250

3350

4500

5700

6800

7950

9050

item

3

2

3

0

1

3

2

3

i=4放入甜瓜

背包负重

1

2

3

4

5

6

7

8

s

6

7

8

p

0

1

2

value

1100

2250

3350

4500

5700

6800

7950

9050

item

3

2

3

0

1

3

2

3

 

    由最后一个表格可以知道,在背包负重8的时候,最多得到价值9050的水果,这个时候可以得到装入的水果是3号水果草莓,那么剩下的(8-1=7)个大小空间,可以知到为2号水果也就是橘子,同理下一步可以知道放入的水果是1号水果苹果。此时获得的最优解的价值就是9050,放入的水果是草莓、橘子和苹果。

你可能感兴趣的:(算法)