完全揹包問題
一個旅行者有一個最多能用m公斤的揹包，現在有n種物品，每件的重量分別是W1，W2，...,Wn,
每件的價值分別為C1,C2,...,Cn.若的每種物品的件數足夠多.
求旅行者能獲得的最大總價值。

貪心演算法（又稱貪婪演算法）是指，在對問題求解時，總是做出在當前看來是最好的選擇。也就是說，不從整體最優上加以考慮，他所做出的僅是在某種意義上的區域性最優解。貪心演算法不是對所有問題都能得到整體最優解，但對範圍相當廣泛的許多問題他能產生整體最優解或者是整體最優解的近似解。

貪心演算法的基本思路

　　下面是一個可以試用貪心演算法解的題目，貪心解的確不錯，可惜不是最優解。

1. /** 
2.  * 揹包貪心法 
3.  *  
4.  * @author *** 
5.  *  
6.  */
7. publicclass Greedy {  
8.     publicstaticvoid main(String[] args) {  
9.         Scanner in = new Scanner(System.in);  
10.         System.out.println("Please enter the number of objects(請輸入物品的數量：):");  
11.         int n = in.nextInt();  
12.         int[] w = newint[n]; // 物品重量陣列
13.         int[] v = newint[n]; // 物品價錢陣列
14.         System.out  
15.                 .println("Now, please enter the weight of these objects(現在請輸入這些物品的重量：)");  
16.         for (int i = 0; i < n; i++) {  
17.             w[i] = in.nextInt();  
18.         }  
19.         System.out  
20.                 .println("Now, please enter the value of these objects(現在請輸入這些物品的價值：)"
    );  
21.         for (int i = 0; i < n; i++) {  
22.             v[i] = in.nextInt();  
23.         }  
24.         System.out  
25.                 .println("Now, please enter the capacity of the pack(現在請輸入揹包的容量：)");  
26.         int c = in.nextInt();  
27.         /** 
28.          * 按單位重量價值r[i] = v[i] / w[i]降序排列 
29.          *  
30.          * ps:排序用到了選擇排序，詳情請檢視選擇排序 
31.          */
32.         double startTime = System.currentTimeMillis();  
33.         double[] r = newdouble[n];  
34.         int[] index = newint[n];  
35.         for (int i = 0; i < n; i++) {  
36.             r[i] = (double) v[i] / (double) w[i];  
37.             index[i] = i;  
38.         }  
39.         double temp = 0;  
40.         for (int i = 0; i < n - 1; i++) {  
41.             for (int j = i + 1; j < n; j++) {  
42.                 if (r[i] < r[j]) {  
43.                     temp = r[i];  
44.                     r[i] = r[j];  
45.                     r[j] = temp;  
46.                     int x = index[i];  
47.                     index[i] = index[j];  
48.                     index[j] = x;  
49.                 }  
50.             }  
51.         }  
52.         /** 
53.          * 排序後的重量和價值分別存到w1[]和v1[]中 
54.          */
55.         int[] w1 = newint[n];  
56.         int[] v1 = newint[n];  
57.         for (int i = 0; i < n; i++) {  
58.             w1[i] = w[index[i]];  
59.             v1[i] = v[index[i]];  
60.         }  
61.         /** 
62.          * 初始化解向量x[n] 
63.          */
64.         int[] x = newint[n];  
65.         for (int i = 0; i < n; i++) {  
66.             x[i] = 0;  
67.         }  
68.         /** 
69.          * 求解並列印解向量 
70.          */
71.         for (int i = 0; i < n; i++) {  
72.             if (w1[i] < c) {  
73.                 x[i] = 1;  
74.                 c = c - w1[i];  
75.             }  
76.         }  
77.         System.out  
78.                 .println("The solution vector is(解向量是：)" + Arrays.toString(x));  
79.         /** 
80.          * 根據解向量求出揹包中存放物品的最大價值並列印 
81.          */
82.         int maxValue = 0;  
83.         for (int i = 0; i < n; i++) {  
84.             if (x[i] == 1)  
85.                 maxValue += v1[i];  
86.         }  
87.         double endTime = System.currentTimeMillis();  
88.         System.out  
89.                 .println("Now, the largest values of objects in the pack is(揹包中物品的最大價值為：)"
90.                         + maxValue);  
91.         System.out.println("Basic Statements take(基本語句用時)"
92.                 + (endTime - startTime) + " milliseconds!");  
93.     }  
94. }  

轉載於：http://blog.csdn.net/double501/article/details/5895201