多重揹包問題：

有N種物品和容量為V的揹包，若第i種物品，容量為v[i]，價值為w[i]，共有n[i]件。怎樣裝才能使揹包內的物品總價值最大？

網上關於“多重揹包”的資料倒是不少，但是關於怎麼實現O(N*V)演算法的資料，真得好少呀，關於“單調佇列”那部分演算法，又沒說明得很清楚，看了幾遍沒看懂原理，只好自己動腦去想怎麼實現O(N*V)演算法。

若用F[i][j]表示對容量為j的揹包，處理完前i種物品後，揹包內物品可達到的最大總價值，並記m[i] = min(n[i], j / v[i])。放入揹包的第i種物品的數目可以是：0、1、2……，可得：

F[i][j] = max { F[i - 1] [j – k * v[i] ] + k * w[i] }  (0 <= k <= m[i])       

如何在O(1)時間內求出F[i][j]呢？

先看一個例子：取m[i] = 2, v[i] = v, w[i] = w, V > 9 * v，

並假設 f(j) = F[i - 1][j]，觀察公式右邊要求最大值的幾項：

j = 6*v:   f(6*v)、f(5*v)+w、f(4*v)+2*w 這三個中的最大值

j = 5*v:   f(5*v)、f(4*v)+w、f(3*v)+2*w 這三個中的最大值

j = 4*v:   f(4*v)、f(3*v)+w、f(2*v)+2*w 這三個中的最大值

顯然，公式㈠右邊求最大值的幾項隨j值改變而改變，但如果將j = 6*v時，每項減去6*w，j=5*v時，每項減去5*w，j=4*v時，每項減去4*w，就得到：

j = 6*v:   f(6*v)-6*w、f(5*v)-5*w、f(4*v)-4*w 這三個中的最大值

j = 5*v:   f(5*v)-5*w、f(4*v)-4*w、f(3*v)-3*w 這三個中的最大值

j = 4*v:   f(4*v)-4*w、f(3*v)-3*w、f(2*v)-2*w 這三個中的最大值

很明顯，要求最大值的那些項，有很多重複。

根據這個思路，可以對原來的公式進行如下調整：

假設d = v[i]，a = j / d，b = j % d，即 j = a * d + b，代入公式㈠，並用k替換a - k得：

F[i][j] = max { F[i - 1] [b + k * d] - k * w[i] } + a * w[i]   (a – m[i] <= k <= a)   

對F[i - 1][y] （y= b  b+d  b+2d  b+3d  b+4d  b+5d  b+6d  …  j）

F[i][j]就是求j的前面m[i] + 1個數對應的F[i - 1] [b + k * d] - k * w[i]的最大值，加上a * w[i]，如果將F[i][j]前面所有的F[i - 1][b + k * d] – k * w放入到一個佇列，那麼，F[i][j]就是求這個佇列最大長度為m[i] + 1時，佇列中元素的最大值，加上a * w[i]。因而原問題可以轉化為：O(1)時間內求一個佇列的最大值。

該問題可以這樣解決：

① 用另一個佇列B記錄指定佇列的最大值（或者記錄最大值的地址），並通過下面兩個操作保證佇列B的第一個元素（或其所指向的元素）一定是指定佇列的當前最大值。

② 當指定佇列有元素M進入時，刪除佇列B中的比M小的（或佇列B中所指向的元素小等於M的）所有元素，並將元素M（或其地址）存入佇列B。

③ 當指定佇列有元素M離開時，佇列B中的第一個元素若與M相等（或佇列B第一個元素的地址與M相等），則佇列B的第一個元素也離隊。

經過上述處理，可以保證佇列B中的第一個元素（或其指向的元素）一定是所指定佇列所有元素的最大值。顯然佇列B的元素（或其所指向的元素）是單調遞減的，這應該就是《揹包九講》中的提到的“單調佇列”吧，初看的時候被這個概念弄得稀裡糊塗，網上的資料提到“維護佇列的最大值”，剛開始還以為是維護這個單調佇列的最大值，對其採用的演算法，越看越糊塗。其實，只要明白用一個“輔助佇列”，求另一個佇列的最值，那麼具體的演算法，和該“輔助佇列”的性質（單調變化），都很容易推匯出來。

在多重揹包問題中，所有要進入佇列的元素個數的上限值是已知的，可以直接用一個大陣列模擬佇列。

“多重揹包”通用模板:

1. //“多重揹包”通用模板  
2. const int MAX_V = 100004;  
3. //v、n、w：當前所處理的這類物品的體積、個數、價值  
4. //V：揹包體積， MAX_V：揹包的體積上限值  
5. //f[i]：體積為i的揹包裝前幾種物品，能達到的價值上限。  
6. inline void pack(int f[], int V, int v, int n, int w)  
7. {  
8.   if (n == 0 || v == 0) return;  
9.   if (n == 1) {               //01揹包  
10.     for (int i = V; i >= v; --i)  
11.       if (f[i] < f[i - v] + w) f[i] = f[i - v] + w;  
12.     return;  
13.   }  
14.   if (n * v >= V - v + 1) {   //完全揹包(n >= V / v)  
15.     for (int i = v; i <= V; ++i)  
16.       if (f[i] < f[i - v] + w) f[i] = f[i - v] + w;  
17.     return;      
18.   }  
19.   int va[MAX_V], vb[MAX_V];   //va/vb: 主/輔助佇列  
20.   for (int j = 0; j < v; ++j) {     //多重揹包  
21.     int *pb = va, *pe = va - 1;     //pb/pe分別指向佇列首/末元素  
22.     int *qb = vb, *qe = vb - 1;     //qb/qe分別指向輔助佇列首/末元素    
23.     for (int k = j, i = 0; k <= V; k += v, ++i) {  
24.       if (pe  == pb + n) {       //若佇列大小達到指定值，第一個元素X出隊。  
25.         if (*pb == *qb) ++qb;   //若輔助佇列第一個元素等於X，該元素也出隊。   
26.         ++pb;  
27.       }  
28.       int tt = f[k] - i * w;  
29.       *++pe = tt;                  //元素X進隊  
30.       //刪除輔助佇列所有小於X的元素，qb到qe單調遞減，也可以用二分法  
31.       while (qe >= qb && *qe < tt) --qe;  
32.       *++qe = tt;              //元素X也存放入輔助佇列          
33.       f[k] = *qb + i * w;      //輔助佇列首元素恆為指定佇列所有元素的最大值  
34.     }  
35.   }  
36. }  

多重揹包特例：物品價值和體積相等（w = v）

由於w = v，上面的程式碼可進行如下修改：

入隊的元素： tt = f[k] - (k / v) * w = f[k] - (k - j) = f[k] - k + j

    返回的最大值：*qb + (k / v) * w =  *qb + k - j

由於j是定值，可調整入隊的元素為: f[k] - k，最大值為 *qb + k

但這種做法相當低效。實際上，這相當於一個“覆蓋”問題：在放入前i個物品後，體積為j的揹包，只存在兩種狀態：是否能剛好裝滿，也就是，是否能被覆蓋。因而只要記錄下該狀態就可以了，前面的分析進行相應的調整：

對F[i - 1][y] （y= b  b+d  b+2d  b+3d  b+4d  b+5d  b+6d  …  j）

F[i][j]就是求j的前面m[i] + 1個數對應的F[i - 1] [b + k * d]（其值為0或1）的最大值，即j前面的m[i] + 1個0、1資料中是否存在1，這又可以簡化為判斷它們的和是否不等於0。

1. //pack-01  
2. const int MAX_V = 100004;  
3. //w = v 特例  
4. inline void pack(bool f[], int V, int v, int n)  
5. {  
6.   if (n == 0 || v == 0) return;  
7.   if (n == 1) {  //01揹包  
8.     for (int i = V; i - v >= 0; --i)  
9.       if (! f[i] && f[i - v]) f[i] = true;  
10.       //if (f[i - v]) f[i] = true;  
11.     return;  
12.   }  
13.   if (n * v >= V - v + 1) {  //完全揹包 n >= V / v  
14.     for (int i = v; i <= V; ++i)  
15.       if (! f[i] && f[i - v]) f[i] = true;  
16.       //if (f[i - v]) f[i] = true;        
17.     return;  
18.   }  
19.    bool va[MAX_V];  
20.     for (int j = 0; j < v; ++j) {     //多重揹包  
21.     bool *pb = va, *pe = va - 1;   
22.     size_t sum = 0;  
23.     for (int k = j; k <= V; k += v) {  
24.       if (pe == pb + n) sum -= *pb++;  //佇列已滿，隊首元素出隊  
25.       *++pe = f[k];  //進隊  
26.       sum += f[k];       
27.       if (! f[k] && sum != 0) f[k] = true;   
28.       //f[k] = (bool)sum;         
29.     }  
30.   }  
31. }  

另外，可以倒著讀資料，這樣就不需要額外使用一個數組存放臨時資料：

1. //pack-02  
2. //w = v 特例  
3. inline void pack(bool f[], int V, int v, int n)  
4. {  
5.   if (n == 0 || v == 0) return;  
6.   if (n == 1) {  //01揹包  
7.     for (int i = V; i - v >= 0; --i)  
8.       if (! f[i] && f[i - v]) f[i] = true;  
9.       //if (f[i - v]) f[i] = true;  
10.     return;  
11.   }  
12.   if (n * v >= V - v + 1) {  //完全揹包 n >= V / v  
13.     for (int i = v; i <= V; ++i)  
14.       if (! f[i] && f[i - v]) f[i] = true;  
15.       //if (f[i - v]) f[i] = true;        
16.     return;  
17.   }  
18.   for (int j = 0; j < v; ++j) {    //多重揹包  
19.     int k = V - j, sum = 0;  
20.     //前n + 1個元素入隊，前面的判斷可以保證： V - j - n * v > 0  
21.     for (; k >= std::max(0, V - j - n * v); k -= v) sum += f[k];  
22.     for (int i = V - j; i > 0; k -= v, i -= v) {  
23.       if (f[i]) --sum;      //出隊: sum -= f[i]   
24.       else if (sum != 0) f[i] = true;  
25.       //int tt = f[i]; f[i] = (bool)sum; sum -= tt;  
26.       if (k >= 0) sum += f[k];        
27.     }  
28.   }   
29. }  

前面的程式碼，都在迴圈中對佇列的元素個數進行判斷，這可以通過下面的方法避免，將迴圈拆分成兩部分：一部分都有入隊和出隊操作、另一部分只有入隊（或出隊）操作。

對該特例，還有一種O(N * V)解法：用一個數組記錄當前物品已經使用數，關鍵程式碼：

if (! f[i] && f[i - v] && count[i - v] < n)

f[i] = true, count[i] = count[i - v] + 1;

每計算一類物品，count陣列都要初始化一次，比較費時，可以再用一個數組記錄上一次處理的物品編號，通過判斷上一次放入那一類的物品編號與當前這類物品編號是否一致（不一致時，相當於count[i]值為0的情況），從而避免對count陣列的初始化操作。還可以將初始化count陣列和後面的迴圈整合在一起。

1. //pack-1    
2. for (int i = 0; i <= V; ++i)  count[i] = 0;  
3. for (int i = v; i <= V; ++i) {     //多重揹包  
4.   if (! f[i] && f[i - v] && count[i - v] < n) {  
5.     count[i] = count[i - v] + 1;   
6.     f[i] = true;  
7.   }  
8. }  

1. //pack-2  cur為當前這類物品的編號  
2. for (int i = v; i <= V; ++i) {     //多重揹包  
3.   if (! f[i] && f[i - v]) {  
4.     if (last[i - v] != cur)  count[i] = 1, last[i] = cur, f[i] = true;  
5.     else if (count[i - v] < n) {  
6.       count[i] = count[i - v] + 1;   
7.       last[i] = cur;  
8.       f[i] = true;  
9.     }  
10.   }  
11. }  

1. //pack-4  
2. for (int i = v; i <= V; ++i) {     //多重揹包  
3.   if (f[i]) count[i] = 0;  
4.   else if (f[i - v]) {  
5.     if (i < 2 * v)  count[i] = 1, f[i] = true;    
6.     else if (count[i - v] < n) {  
7.       count[i] = count[i - v] + 1;  
8.       f[i] = true;  
9.     }    
10.   }  
11. }  

POJ 1742：有若干不同面值的紙幣，問能組合出1到m中的幾種面值？

1. //poj1742   
2. #include<algorithm>  
3. #include<cstdio>  
4. #define AB 0  
5. //MAX_N 物品種類數最大值 MAX_n每種物品數目的最大值，MAX_V揹包體積最大值  
6. const int MAX_N = 101, MAX_V = 100004;  
7. //w = v特例  
8. inline void pack(bool f[], int V, int v, int n, int& total)  
9. {  
10.   //if (n == 0 || v == 0) return;  
11.   if (n == 1) {  //01揹包  
12.     for (int i = V; i - v >= 0; --i)  
13.       if (! f[i] && f[i - v]) f[i] = true, ++total;  
14.     return;  
15.   }  
16.   if (n * v >= V - v + 1) {  //完全揹包 n >= V / v  
17.     for (int i = v; i <= V; ++i)  
18.       if (! f[i] && f[i - v]) f[i] = true, ++total;  
19.     return;  
20.   }  
21.   for (int j = 0; j < v; ++j) {    //多重揹包  
22.     int k = V - j, sum = 0;  
23.     //前n + 1個元素入隊，前面的判斷可以保證： V - j - n * v > 0  
24.     for (; k >= V - j - n * v; k -= v) sum += f[k];  
25.     for (int i = V - j; i > 0; k -= v, i -= v) {  
26.       if (f[i]) --sum;      //出隊: sum -= f[i]   
27.       else if (sum != 0) f[i] = true, ++total;  
28.       //int tt = f[i]; f[i] = (bool)sum; sum -= tt;  
29.       if (k >= 0) sum += f[k];        
30.     }  
31.   }  
32. }  
33. struct Node {  
34.   int n, v, V;  
35.   bool operator<(const Node& other) const { return V < other.V;}   
36. };  
37. int main()  
38. {  
39. #if AB == 1  
40.   freopen("src.txt","r",stdin);  
41.   freopen("z-b.txt","w",stdout);  
42. #endif    
43.   Node node[MAX_N];  
44.   int V, N;  
45.   bool f[MAX_V];  
46.   while (scanf("%d %d",&N,&V) != EOF) {  
47.     if (N + V == 0) break;  
48.     Node *np = node + N;  
49.     for (Node *p = node; p < np; ++p) scanf("%d", &p->v);  
50.     for (Node *p = node; p < np; ++p) {  
51.       scanf("%d", &p->n);  
52.       p->V = std::min(p->n * p->v, V);  
53.     }  
54.     std::sort(node, np);  
55.     int total = 0;  
56.     f[0] = true;  
57.     for (int i = 1; i <= V; ++i) f[i] = false;  
58.     int mv = 0;  
59.     for (Node *p = node; p < np && total < V; ++p) {  
60.       mv = std::min(mv + p->V, V);  
61.       pack(f,mv,p->v,p->n, total);  
62.     }  
63.     printf("%d/n",total);  
64.   }  
65. }  

用自己隨機生成的資料測試了下，上面提到的幾種方法，所用時間都是7秒多點，有排序的比沒排序的稍微快點。但在POJ上提交的結果，不同程式碼的耗時相差挺大，快的在1秒左右，慢的接近1.5秒。

還有一種特例：

給定面值為1、2、5的紙幣若干個，問其所不能支付的最低價格（假設為自然數）。

這可以用多重揹包（或母函式）來解決，但實際上是有O(1)解法的。