01 揹包

有n 種不同的物品，每個物品有兩個屬性，size 體積，value 價值，現在給一個容量為 w 的揹包，問最多可帶走多少價值的物品。  

1. int f[w+1];   //f[x] 表示揹包容量為x 時的最大價值
2. for (int i=0; i<n; i++)  
3.     for (int j=w; j>=size[i]; j--)  
4.         f[j] = max(f[j], f[j-size[i]]+value[i]);  

完全揹包

如果物品不計件數，就是每個物品不只一件的話，稍微改下即可  

1. for (int i=0; i<n; i++)  
2.     for (int j=size[i]; j<=w; j++)  
3.         f[j] = max(f[j], f[j-size[i]]+value[i]);  

 f[w] 即為所求  
        初始化分兩種情況：
        1、如果揹包要求正好裝滿則初始化 f[0] = 0, f[1~w] = -INF;  

        2、如果不需要正好裝滿 f[0~v] = 0;  

        舉例：

01揹包

V=10，N=3，c[]={3,4,5}, w={4,5,6}

（1）揹包不一定裝滿

      計算順序是：從右往左，自上而下：因為每個物品只能放一次，前面的體積小的會影響體積大的

（2）揹包剛好裝滿    

      計算順序是：從右往左，自上而下。注意初始值，其中-inf表示負無窮

完全揹包：

V=10，N=3，c[]={3,4,5}, w={4,5,6}

（1）揹包不一定裝滿

計算順序是：從左往右，自上而下：  每個物品可以放多次，前面的會影響後面的

（2）揹包剛好裝滿

計算順序是：從左往右，自上而下。注意初始值，其中-inf表示負無窮

多重揹包：  
         多重揹包問題要求很簡單，就是每件物品給出確定的件數，求可得到的最大價值  
         多重揹包轉換成 01 揹包問題就是多了個初始化，把它的件數C 用二進位制分解成若干個件數的集合，這裡面數字可以組合成任意小於等於C的件數，而且不會重複，之所以叫二進位制分解，是因為這樣分解可以用數字的二進位制形式來解釋  
       比如：7的二進位制 7 = 111 它可以分解成 001 010 100 這三個數可以組合成任意小於等於7 的數，而且每種組合都會得到不同的數  
       15 = 1111 可分解成 0001  0010  0100  1000 四個數字  
        如果13 = 1101 則分解為 0001 0010 0100 0110 前三個數字可以組合成  7以內任意一個數，即1、2、4可以組合為1——7內所有的數，加上 0110 = 6 可以組合成任意一個大於6 小於等於13的數，比如12，可以讓前面貢獻6且後面也貢獻6就行了。雖然有重複但總是能把 13 以內所有的數都考慮到了，基於這種思想去把多件物品轉換為，多種一件物品，就可用01 揹包求解了。  
       看程式碼：  

1. int n;  //輸入有多少種物品
2. int c;  //每種物品有多少件
3. int v;  //每種物品的價值
4. int s;  //每種物品的尺寸
5. int count = 0; //分解後可得到多少種物品
6. int value[MAX]; //用來儲存分解後的物品價值
7. int size[MAX];  //用來儲存分解後物品體積
8. scanf("%d", &n);    //先輸入有多少種物品，接下來對每種物品進行分解
9. while (n--)     //接下來輸入n中這個物品
10. {  
11.     scanf("%d%d%d", &c, &s, &v);  //輸入每種物品的數目和價值
12.     for (int k=1; k<=c; k<<=1)   //<<右移 相當於乘二
13.     {  
14.         value[count] = k*v;  
15.         size[count++] = k*s;  
16.         c -= k;  
17.     }  
18.     if (c > 0)  
19.     {  
20.         value[count] = c*v;  
21.         size[count++] = c*s;  
22.     }  
23. }  

定理：一個正整數n可以被分解成1,2,4,…,2^(k-1),n-2^k+1（k是滿足n-2^k+1>0的最大整數）的形式，且1～n之內的所有整數均可以唯一表示成1,2,4,…,2^(k-1),n-2^k+1中某幾個數的和的形式。

證明如下：

（1） 數列1,2,4,…,2^(k-1),n-2^k+1中所有元素的和為n，所以若干元素的和的範圍為：[1, n]；

（2）如果正整數t<= 2^k – 1,則t一定能用1,2,4,…,2^(k-1)中某幾個數的和表示，這個很容易證明：我們把t的二進位制表示寫出來，很明顯，t可以表示成n=a0*2^0+a1*2^1+…+ak*2^（k-1），其中ak=0或者1，表示t的第ak位二進位制數為0或者1.

（3）如果t>=2^k,設s=n-2^k+1，則t-s<=2^k-1，因而t-s可以表示成1,2,4,…,2^(k-1)中某幾個數的和的形式，進而t可以表示成1,2,4,…,2^(k-1)，s中某幾個數的和（加數中一定含有s）的形式。

（證畢！）

        現在用count 代替 n 就和01 揹包問題完全一樣了  

杭電2191題解：此為多重揹包用01和完全揹包：

1. #include<stdio.h>
2. #include<string.h>
3. int dp[102];  
4. int p[102],h[102],c[102];  
5. int n,m;  
6. void comback(int v,int w)//經費，重量。完全揹包；
7. {  
8.     for(int i=v; i<=n; i++)  
9.         if(dp[i]<dp[i-v]+w)  
10.             dp[i]=dp[i-v]+w;  
11. }  
12. void oneback(int v,int w)//經費，重量；01揹包；
13. {  
14.     for(int i=n; i>=v; i--)  
15.         if(dp[i]<dp[i-v]+w)  
16.             dp[i]=dp[i-v]+w;  
17. }  
18. int main()  
19. {  
20.     int ncase,i,j,k;  
21.     scanf("%d",&ncase);  
22.     while(ncase--)  
23.     {  
24.         memset(dp,0,sizeof(dp));  
25.         scanf("%d%d",&n,&m);//經費，種類；
26.         for(i=1; i<=m; i++)  
27.         {  
28.             scanf("%d%d%d",&p[i],&h[i],&c[i]);//價值，重量，數量;
29.             if(p[i]*c[i]>=n) comback(p[i],h[i]);  
30.             else
31.             {  
32.                 for(j=1; j<c[i]; j<<1)  
33.                 {  
34.                     oneback(j*p[i],j*h[i]);  
35.                     c[i]=c[i]-j;  
36.                 }  
37.                 oneback(p[i]*c[i],h[i]*c[i]);  
38.             }  
39.         }  
40.         printf("%d\n",dp[n]);  
41.     }  
42.     return 0;  
43. }  

只是用01揹包，用二進位制優化：

1. #include <iostream>
2. usingnamespace std;  
3. int main()  
4. {  
5.     int nCase,Limit,nKind,i,j,k,  v[111],w[111],c[111],dp[111];  
6.     //v[]存價值，w[]存尺寸，c[]存件數
7.     //在本題中，價值是米的重量，尺寸是米的價格
8.     int count,Value[1111],size[1111];  
9.     //count儲存分解完後的物品總數
10.     //Value儲存分解完後每件物品的價值
11.     //size儲存分解完後每件物品的尺寸
12.     cin>>nCase;  
13.     while(nCase--)  
14.     {  
15.         count=0;  
16.         cin>>Limit>>nKind;  
17.         for(i=0; i<nKind; i++)  
18.         {  
19.             cin>>w[i]>>v[i]>>c[i];  
20.             //對該種類的c[i]件物品進行二進位制分解
21.             for(j=1; j<=c[i]; j<<=1)  
22.             {  
23.                 //<<左移1位，相當於乘2
24.                 Value[count]=j*v[i];  
25.                 size[count++]=j*w[i];  
26.                 c[i]-=j;  
27.             }  
28.             if(c[i]>0)  
29.             {  
30.                 Value[count]=c[i]*v[i];  
31.                 size[count++]=c[i]*w[i];  
32.             }  
33.         }  
34.         //經過上面對每一種物品的分解，
35.         //現在Value[]存的就是分解後的物品價值
36.         //size[]存的就是分解後的物品尺寸
37.         //count就相當於原來的n
38.         //下面就直接用01揹包演算法來解
39.         memset(dp,0,sizeof(dp));  
40.         for

    相關推薦

    揹包模板（01，完全，多重揹包的二進位制優化和單調佇列優化

    揹包問題 1，01揹包 揹包問題的基礎，總體積為V的揹包，有n件體積v【i】，價值w【i】的物品，求能裝物品的最大總價值 void zero(int v,int w) { for(int j=V;j>=v;j--) { dp[j]=max(dp[j],dp[j

    詳解 01，完全，多重揹包

    揹包問題泛指以下這一種問題： 給定一組有固定價值和固定重量的物品，以及一個已知最大承重量的揹包，求在不超過揹包最大承重量的前提下，能放進揹包裡面的物品的最大總價值。 這一類問題是典型的使用動態規劃解決的問題，我們可以把揹包問題分成3種不同的子問題：0-1揹包問題、完全揹包和多重揹包問題。下面對這三種問題分別進

    揹包九講--多重揹包的原理及程式碼實現

    本文節選這篇部落格:http://blog.csdn.net/tinyguyyy/article/details/51203935 這篇文章的內容RT 個人認為01揹包和完全揹包揹包九講講的很具體了，多重揹包關於二進位制思想的我的沒有接觸過，有點不求甚解，所

    揹包九講——多重揹包

    多重揹包是完全揹包的升級版，是《揹包問題九講》裡的第三講，先來看看《揹包問題九講》是怎麼表述這個問題的： 題目 有N種物品和一個容量為V的揹包。第i種物品最多有n[i]件可用，每件費用是c[i]，價值是w[i]。求解將哪些物品裝入揹包可使這些物品的

    01、完全、多重背包模板

    int soft ont family color 限制 else 完全背包 log 背包問題： 背包總容量為W，有n件重量為weight[i],權值為value[i]的物品 1、01背包： 這是最基礎的背包問題，特點是：每種物品僅有一件，可以選擇放或不放。 1 void

    背包問題專欄（01，完全，多重）

    c++ gif 什麽 就是 pri tps 需要 info 方程 本題的模板是套用了 A.S.KirigiriKyouko 的模板。請dalao見諒 一、01背包 有N件物品和一個容量為V的背包。第i件物品的價格（即體積，下同）是w[i]，價值是c[i]。求解將哪些

    演算法模板(一) 01揹包，多重揹包，完全揹包

    01揹包 #include<bits/stdc++.h> using namespace std; int dp[300][3000]; int w[3000],v[3000]; int N,V; int main(){ cin>>N>>V; for(re

    【揹包問題】 01揹包+完全揹包+多重揹包

    前言 揹包問題(Knapsack problem)是一種組合優化的NP完全問題。問題可以描述為：給定一組物品，每種物品都有自己的重量和價格，在限定的總重量內，我們如何選擇，才能使得物品的總價格最高。問題的名稱來源於如何選擇最合適的物品放置於給定揹包中。相似問題經常出現在商業、組合數學，計算複

    揹包問題-01揹包，完全揹包，多重揹包

    揹包問題-01揹包，完全揹包，多重揹包 01揹包： 概念： 有Goods_Num件物品，MAX_Volume的最大裝載量，每種物品只有一件，每種物品都有對應的重量或者說體積Volume[i]，價值Value[i]，求解裝包的最大價值 狀態轉移方程推

    揹包問題（01揹包 完全揹包 多重揹包）

    今天刷牛客網題目，用到揹包問題的求解。在這裡總結一下揹包問題。 揹包問題主要分為以下三種： 01揹包 完全揹包 多重揹包 01揹包問題 有N件物品和一個容量為V的揹包。第i件物品的價格（即體積，下同）是w[i]，價值是c[i]。求解將哪些物品裝入

    【揹包問題】 01揹包+完全揹包+多重揹包

    前言 揹包問題(Knapsack problem)是一種組合優化的NP完全問題。問題可以描述為：給定一組物品，每種物品都有自己的重量和價格，在限定的總重量內，我們如何選擇，才能使得物品的總價格最高。問題的名稱來源於如何選擇最合適的物品放置於給定揹包中。相似問題經常出現在商業

    揹包問題小總結 習題（動態規劃01揹包（第k優解）完全揹包，多重揹包）acm杭電HDU2639，HDU2602，HDU1114，HDU2191

    1、01揹包（每種物品只有一個） 題目 有N件物品和一個容量為V的揹包。第i件物品的費用是c[i]，價值是w[i]。 求解將哪些物 品裝入揹包可使價值總和最大。 基本思路 這是最基礎的揹包問題，特點是：每種物品僅有一件，可以選擇放或不放。 用子問題定義狀態：    

    史上最易懂的01揹包，完全揹包，多重揹包講解

                                            揹包之01揹包、完全揹包、多重揹包詳解 PS：大家覺得寫得還過得去，就幫我把部落格頂一下，謝謝。 首先說下動態規劃，動態規劃這東西就和遞迴一樣，只能找區域性關係，若想全部列出來，是很難的，比

    01揹包、完全揹包、多重揹包、分組揹包

    參考連結： 各種揹包的描述： 01揹包（ZeroOnePack）: 有N件物品和一個容量為V的揹包。（每種物品均只有一件）第i件物品的費用是c[i]，價值是w[i]。求解將哪些物品裝入揹包可使價值總和最大。 完全揹包(CompletePack): 有N種

    揹包問題詳解：01揹包、完全揹包、多重揹包

    參考連結： 揹包問題是動態規劃演算法的一個典型例項，首先介紹動態規劃演算法： 動態規劃： 基本思想： 動態規劃演算法通常用於求解具有某種最優性質的問題。在這類問題中， 可能會有很多可行解。沒一個解都對應於一個值，我們希望找到具有最優值的解。胎動規

    01揹包，完全揹包，多重揹包

    01揹包 #include <stdio.h> int c[101][1001]={0};//定義100個物品1000重量的總價值陣列 void calcMaxValues(int n,

    【揹包問題】01揹包 多重揹包 完全揹包

    01揹包 0-1揹包問題是指每一種物品都只有一件，可以選擇放或者不放。 方法一 V(i,j)表示前i種物品恰放入一個容量為j的揹包的最大價值，因此狀態轉移方程： j<w(i) V(i,j)=V(i-1,j) j>=w(i) V(i,j)=m

    01揹包+完全揹包+多重揹包

    01 揹包 有n 種不同的物品，每個物品有兩個屬性，size 體積，value 價值，現在給一個容量為 w 的揹包，問最多可帶走多少價值的物品。   int f[w+1];   //f[x] 表示揹包容量為x 時的最大價值 for (int i=0; i<

    HDU2602/HDU1114/HDU2191(重新整理一下01揹包，完全揹包，多重揹包)

    好長時間不做揹包的問題，有一點遺忘，現在把這些問題整理一下~ 一.01揹包(HDU2602) 題目：http://acm.hdu.edu.cn/showproblem.php?pid=2602 題意就

    DP揹包之01揹包、完全揹包、多重揹包筆記

    這是個經典話題，值得好好研究一番，本文作為學習筆記將會不斷更新。 主要參考了以下資料： 受益匪淺！ 以下是Java的實現： package DP; import java.util.Arrays; public class Knapsack01 { s