【0/1背包問題】
在0/1背包問題中，需對容量為c 的背包進行裝載。從n 個物品中選取裝入背包的物品，每件物品i 的重量為wi ，價值為pi 。對於可行的背包裝載，背包中物品的總重量不能超過背包的容量，最佳裝載是指所裝入的物品價值最高，即p1*x1+p2*x1+...+pi*xi(其1<=i<=n，x取0或1，取1表示選取物品i) 取得最大值。
【輸入文件】
第一行一個數c，為背包容量。
第二行一個數n，為物品數量
第三行n個數，以空格間隔，為n個物品的重量
第四行n個數，以空格間隔，為n個物品的價值
【輸出文件】
能取得的最大價值。
【分析】
初看這類問題，第一個想到的會是貪心，但是貪心法卻無法保證一定能得到最優解，看以下實例：
貪心准則1：從剩余的物品中，選出可以裝入背包的價值最大的物品，利用這種規則，價值最大的物品首先被裝入（假設有足夠容量），然后是下一個價值最大的物品，如此繼續下去。這種策略不能保證得到最優解。例如，考慮n=2, w=[100,10,10], p =[20,15,15], c =105。當利用價值貪婪准則時，獲得的解為x= [1,0,0]，這種方案的總價值為20。而最優解為[0,1,1]，其總價值為30。
貪心准則2：從剩下的物品中選擇可裝入背包的重量最小的物品。雖然這種規則對於前面的例子能產生最優解，但在一般情況下則不一定能得到最優解。考慮n= 2 ,w=[10,20], p=[5,100], c= 2 5。當利用重量貪婪策略時，獲得的解為x =[1,0], 比最優解[ 0 , 1 ]要差。
貪心准則3：價值密度pi /wi 貪婪算法，這種選擇准則為：從剩余物品中選擇可 裝入包的pi /wi 值最大的物品，但是這種策略也不能保證得到最優解。利用此策略解 n=3 ,w=[20,15,15], p=[40,25,25], c=30 時的得到的就不是最優解。
由此我們知道無法使用貪心算法來解此類問題。我們采用如下思路：
在該問題中需要決定x1 .. xn的值。假設按i = 1，2，...，n 的次序來確定xi 的值。如果置x1 = 0，則問題轉變為相對於其余物品(即物品2，3，.，n)，背包容量仍為c 的背包問題。若置x1 = 1，問題就變為關於最大背包容量為c-w1 的問題。現設r={c，c-w1} 為剩余的背包容量。在第一次決策之后，剩下的問題便是考慮背包容量為r 時的決策。不管x1 是0或是1，[x2 ，.，xn ] 必須是第一次決策之后的一個最優方案。也就是說在此問題中，最優決策序列由最優決策子序列組成。
假設f (i,j) 表示剩余容量為j，剩余物品為i，i + 1，...，n 時的最優解的值，即：利用最優序列由最優子序列構成的結論，可得到f 的遞歸式為：
當j≥wi時： f(i,j)=max{f(i+1,j),f(i+1,j-wi)+pi}
當0≤j<wi時：f(i,j)=f(i+1,j)
這是一個遞歸的算法，其時間效率較低，為指數級。
考慮用動態規划的方法來解決:
階段：在前i件物品中，選取若干件物品放入背包中；
狀態：在前i件物品中，選取若干件物品放入所剩空間為c的背包中的所能獲得的最大價值；
決策：第i件物品放或者不放；
由此可以寫出動態轉移方程：
用f[i,j]表示在前 i 件物品中選擇若干件放在所剩空間為 j 的背包里所能獲得的最大價值
f[i,j]=max{f[i-1,j-wi]+pi (j>=wi), f[i-1,j]}
這樣，就可以自底向上地得出在前n件物品中取出若干件放進背包能獲得的最大價值，也就是f[n,c]
算法框架如下：
for i:=0 to c do {i=0也就是沒有物品時清零}
f[0,i]:=0;
for i:=1 to n do {枚舉n件物品}
for j:=0 to c do {枚舉所有的裝入情況}
begin
f[i,j]:=f[i-1,j]; {先讓本次裝入結果等於上次結果}
if (j>=w[i]) and (f[i-1,j-w[i]]+p[i]>f[i,j]) {如果能裝第i件物品}
then f[i,j]:=f[i-1,j-w[i]]+p[i]; {且裝入后價值變大則裝入}
end;
writeln(f[n,c]);
為了進一步說明算法的執行原理，下面給出一個實例：
【輸入文件】
10
4
5 1 4 3
40 10 25 30
【輸出結果】下面列出所有的f[i,j]
0 0 0 0 40 40 40 40 40 40
10 10 10 10 40 50 50 50 50 50
10 10 10 25 40 50 50 50 65 75
10 10 30 40 40 50 55 70 80 80
從以上的數據中我們可以清晰地看到每一次的枚舉結果，每一行都表示一個階段。
1.遞歸思想
0- 1 背包問題如果采用遞歸算法來描述則非常清楚明白, 它的算法根本思想是假設用布爾函數
knap( s, n) 表示n 件物品放入可容質量為s 的背包中是否有解( 當knap 函數的值為真時
說明問題有解,其值為假時無解) . 我們可以通過輸入s 和n 的值, 根據它們的值可分為以下幾種情況討論:
( 1) 當s= 0時可知問題有解, 即函數knap( s, n) 的值為true; ( 2) 當s< 0 時這時不可能,
所以函數值為false; ( 3) 當輸入的s> 0 且n< 1 時即總物品的件數不足1, 這時函數值為false,
只有s> 0 且n \1 時才符合實際情況,這時又分為兩種情況: ( 1) 選擇的一組物體中不包括Wn
則knap( s, n) 的解就是knap( s, n- 1) 的解. ( 2) 選擇的一組物體中包括Wn 則knap( s, n) 的解
就是knap( s- Wn, n- 1) 的解. 這樣一組Wn 的值就是問題的最佳解. 這樣就將規模為n 的問題轉化為
規模為n- 1 的問題. 綜上所述0- 1 背包問題的遞歸函數定義為:
knap( s, n) =∕true, s= 0
︳false, s< 0
︳false, s> 0 且n< 1
\knap( s, n- 1) 或knap( s- Wn, n- 1) , s> 0 且n>= 1
采用此法求解0- 1 背包問題的時間復雜度為O( n) . 上述算法對於所有物品中的某幾件恰能裝滿背包
時能准確求出最佳解. 但一般情況是對於某一些物品無論怎么裝都不能裝滿背包, 必須要按背包的最大
容量來裝. 如物品件數為4, 其質量分別為: 10, 2, 5, 4, 背包的容量為20, 則這四件物品無論怎么放都不
能恰好裝滿背包, 但應能最大限度裝, 即必須裝下10, 5, 4 這三件物品, 這樣就能得到最大質量19. 對於
這種裝不滿的背包它的解決辦法是這樣的: 按所有物品的組合質量最大的方法裝背包, 如果還裝不滿,
則我們可以考慮剩余空間能否裝下所有物品中最小的那件, 如果連最小的都裝不下了則說明這樣得到
的解是最佳解, 問題解決. 這樣我們必須先找出所有n 件物品中質量最小的那件( 它的質量為Min) , 但
是為了問題的解決我們不能增加運算次數太多, 並且必須運用上述遞歸函數. 那么我們可通過修改s 的
值即背包的容量, 從背包容量s 中減去k( 它的值是從0 到Min- 1 之間的一個整數值) , 再調用遞歸函
數. 當k= 0 時即能裝滿背包, 其它值也能保證背包能最大限度裝滿, 這樣所有問題都解決了.
①例題一：
簡單背包問題
Time Limit: 1000MS Memory Limit: 65535KB
Submissions: 2217 Accepted: 408
Description
設有一個背包可以放入的物品重量為S，現有n件物品，重量分別是w1，w2，w3，…wn。
問能否從這n件物品中選擇若干件放入背包中，使得放入的重量之和正好為S。
如果有滿足條件的選擇，則此背包有解，否則此背包問題無解。
Input輸入數據有多行，包括放入的物品重量為s，物品的件數n，以及每件物品的重量（輸入數據均為正整數）
多組測試數據。
Output對於每個測試實例，若滿足條件則輸出“YES”，若不滿足則輸出“NO“
Sample Input
20 5
1 3 5 7 9
Sample Output
YES
View Code
1 # include<stdio.h> 2 # include<string.h> 3 int date[1005]; 4 int f(int w,int s) 5 { 6 if(w==0) return 1;//正好 7 if(w<0||w>0 &&s==0) return 0; 8 if(f(w-date[s],s-1)) return 1;//退出來再選下一個 9 return f(w,s-1);//選擇下一個 10 } 11 12 int main() 13 { 14 int i,Weight,n; 15 while(scanf("%d %d",&Weight,&n)!=EOF) 16 { 17 memset(date,0,sizeof(date)); 18 for(i=1;i<=n;i++) 19 scanf("%d",&date[i]); 20 if(f(Weight,n)) 21 printf("YES\n"); 22 else printf("NO\n"); 23 } 24 return 0; 25 } 26 }
01背包問題
01背包問題：
1.遞歸思想
0- 1 背包問題如果采用遞歸算法來描述則非常清楚明白, 它的算法根本思想是假設用布爾函數
knap( s, n) 表示n 件物品放入可容質量為s 的背包中是否有解( 當knap 函數的值為真時
說明問題有解,其值為假時無解) . 我們可以通過輸入s 和n 的值, 根據它們的值可分為以下幾種情況討論:
( 1) 當s= 0時可知問題有解, 即函數knap( s, n) 的值為true; ( 2) 當s< 0 時這時不可能,
所以函數值為false; ( 3) 當輸入的s> 0 且n< 1 時即總物品的件數不足1, 這時函數值為false,
只有s> 0 且n \1 時才符合實際情況,這時又分為兩種情況: ( 1) 選擇的一組物體中不包括Wn
則knap( s, n) 的解就是knap( s, n- 1) 的解. ( 2) 選擇的一組物體中包括Wn 則knap( s, n) 的解
就是knap( s- Wn, n- 1) 的解. 這樣一組Wn 的值就是問題的最佳解. 這樣就將規模為n 的問題轉化為
規模為n- 1 的問題. 綜上所述0- 1 背包問題的遞歸函數定義為:
knap( s, n) =∕true, s= 0
︳false, s< 0
︳false, s> 0 且n< 1
\knap( s, n- 1) 或knap( s- Wn, n- 1) , s> 0 且n>= 1
采用此法求解0- 1 背包問題的時間復雜度為O( n) . 上述算法對於所有物品中的某幾件恰能裝滿背包
時能准確求出最佳解. 但一般情況是對於某一些物品無論怎么裝都不能裝滿背包, 必須要按背包的最大
容量來裝. 如物品件數為4, 其質量分別為: 10, 2, 5, 4, 背包的容量為20, 則這四件物品無論怎么放都不
能恰好裝滿背包, 但應能最大限度裝, 即必須裝下10, 5, 4 這三件物品, 這樣就能得到最大質量19. 對於
這種裝不滿的背包它的解決辦法是這樣的: 按所有物品的組合質量最大的方法裝背包, 如果還裝不滿,
則我們可以考慮剩余空間能否裝下所有物品中最小的那件, 如果連最小的都裝不下了則說明這樣得到
的解是最佳解, 問題解決. 這樣我們必須先找出所有n 件物品中質量最小的那件( 它的質量為Min) , 但
是為了問題的解決我們不能增加運算次數太多, 並且必須運用上述遞歸函數. 那么我們可通過修改s 的
值即背包的容量, 從背包容量s 中減去k( 它的值是從0 到Min- 1 之間的一個整數值) , 再調用遞歸函
數. 當k= 0 時即能裝滿背包, 其它值也能保證背包能最大限度裝滿, 這樣所有問題都解決了.
①例題一：
簡單背包問題
Time Limit: 1000MS Memory Limit: 65535KB
Submissions: 2217 Accepted: 408
Description
設有一個背包可以放入的物品重量為S，現有n件物品，重量分別是w1，w2，w3，…wn。
問能否從這n件物品中選擇若干件放入背包中，使得放入的重量之和正好為S。
如果有滿足條件的選擇，則此背包有解，否則此背包問題無解。
Input輸入數據有多行，包括放入的物品重量為s，物品的件數n，以及每件物品的重量（輸入數據均為正整數）
多組測試數據。
Output對於每個測試實例，若滿足條件則輸出“YES”，若不滿足則輸出“NO“
Sample Input
20 5
1 3 5 7 9
Sample Output
YES
2.貪心算法
用貪心法設計算法的特點是一步一步地進行，根據某個優化測度（可能是目標函數，也可能不是目標函數），每一步上都要保證能獲得局部最優解。
每一步只考慮一個數據，它的選取應滿足局部優化條件。若下一個數據與部分最優解連在一起不再是可行解時，就不把該數據添加到部分解中，
直到把所有數據枚舉完，或者不能再添加為止。
View Code
1 #include<iostream> 2 #include<algorithm> 3 using namespace std; 4 struct good//表示物品的結構體 5 { 6 double p;//價值 7 double w;//重量 8 double r;//價值與重量的比 9 }; 10 good a[2000]; 11 bool bigger(good a,good b) 12 { 13 if(a.r==b.r)return a.w<b.w; 14 else return a.r>b.r; 15 } 16 int main() 17 { 18 double s,value,m; 19 int i,n; 20 cin>>m>>n;//讀入包的容量和物品個數 21 for (i=0;i<n;i++) 22 { 23 cin>>a[i].w>>a[i].p; 24 a[i].r=a[i].p/a[i].w; 25 } 26 sort(a,a+n,bigger);//調用sort排序函數，按照價值與重量比和質量排序貪心 27 s=0;//包內現存貨品的重量 28 value=0;//包內現存貨品總價值 29 for (i=0;i<n;i++) 30 if(s+a[i].w<=m) 31 { 32 value+=a[i].p; 33 s+=a[i].w; 34 } 35 cout<<"The total value is "<<value<<endl;//輸出結果 36 return 0; 37 }
01背包問題
01背包問題：
1.遞歸思想
0- 1 背包問題如果采用遞歸算法來描述則非常清楚明白, 它的算法根本思想是假設用布爾函數
knap( s, n) 表示n 件物品放入可容質量為s 的背包中是否有解( 當knap 函數的值為真時
說明問題有解,其值為假時無解) . 我們可以通過輸入s 和n 的值, 根據它們的值可分為以下幾種情況討論:
( 1) 當s= 0時可知問題有解, 即函數knap( s, n) 的值為true; ( 2) 當s< 0 時這時不可能,
所以函數值為false; ( 3) 當輸入的s> 0 且n< 1 時即總物品的件數不足1, 這時函數值為false,
只有s> 0 且n \1 時才符合實際情況,這時又分為兩種情況: ( 1) 選擇的一組物體中不包括Wn
則knap( s, n) 的解就是knap( s, n- 1) 的解. ( 2) 選擇的一組物體中包括Wn 則knap( s, n) 的解
就是knap( s- Wn, n- 1) 的解. 這樣一組Wn 的值就是問題的最佳解. 這樣就將規模為n 的問題轉化為
規模為n- 1 的問題. 綜上所述0- 1 背包問題的遞歸函數定義為:
knap( s, n) =∕true, s= 0
︳false, s< 0
︳false, s> 0 且n< 1
\knap( s, n- 1) 或knap( s- Wn, n- 1) , s> 0 且n>= 1
采用此法求解0- 1 背包問題的時間復雜度為O( n) . 上述算法對於所有物品中的某幾件恰能裝滿背包
時能准確求出最佳解. 但一般情況是對於某一些物品無論怎么裝都不能裝滿背包, 必須要按背包的最大
容量來裝. 如物品件數為4, 其質量分別為: 10, 2, 5, 4, 背包的容量為20, 則這四件物品無論怎么放都不
能恰好裝滿背包, 但應能最大限度裝, 即必須裝下10, 5, 4 這三件物品, 這樣就能得到最大質量19. 對於
這種裝不滿的背包它的解決辦法是這樣的: 按所有物品的組合質量最大的方法裝背包, 如果還裝不滿,
則我們可以考慮剩余空間能否裝下所有物品中最小的那件, 如果連最小的都裝不下了則說明這樣得到
的解是最佳解, 問題解決. 這樣我們必須先找出所有n 件物品中質量最小的那件( 它的質量為Min) , 但
是為了問題的解決我們不能增加運算次數太多, 並且必須運用上述遞歸函數. 那么我們可通過修改s 的
值即背包的容量, 從背包容量s 中減去k( 它的值是從0 到Min- 1 之間的一個整數值) , 再調用遞歸函
數. 當k= 0 時即能裝滿背包, 其它值也能保證背包能最大限度裝滿, 這樣所有問題都解決了.
①例題一：
簡單背包問題
Time Limit: 1000MS Memory Limit: 65535KB
Submissions: 2217 Accepted: 408
Description
設有一個背包可以放入的物品重量為S，現有n件物品，重量分別是w1，w2，w3，…wn。
問能否從這n件物品中選擇若干件放入背包中，使得放入的重量之和正好為S。
如果有滿足條件的選擇，則此背包有解，否則此背包問題無解。
Input輸入數據有多行，包括放入的物品重量為s，物品的件數n，以及每件物品的重量（輸入數據均為正整數）
多組測試數據。
Output對於每個測試實例，若滿足條件則輸出“YES”，若不滿足則輸出“NO“
Sample Input
20 5
1 3 5 7 9
Sample Output
YES
2.貪心算法
用貪心法設計算法的特點是一步一步地進行，根據某個優化測度（可能是目標函數，也可能不是目標函數），每一步上都要保證能獲得局部最優解。
每一步只考慮一個數據，它的選取應滿足局部優化條件。若下一個數據與部分最優解連在一起不再是可行解時，就不把該數據添加到部分解中，
直到把所有數據枚舉完，或者不能再添加為止。
但仔細想就會發現有個很大的問題，
10 4
5 10
8 16
5 5
10 10
就會出問題，被裝進去就不會拿出來，可見“拿來主義”行不通！
接下來介紹另一種算法：動規
3.動態規划【正解】
有N件物品和一個容量為V的背包。第i件物品的體積是c[i]，價值是w[i]。求解將哪些物品裝入背包可使價值總和最大。
狀態轉移方程：
f[i][v]=max{f[i-1][v],f[i-1][v-c[i]]+w[i]}
這個方程非常重要，基本上所有跟背包相關的問題的方程都是由它衍生出來的
偽碼：
for i=1..N
for v=V..0
f[v]=max{f[v],f[v-c[i]]+w[i]};
如果不放第i件物品，那么問題就轉化為“前i-1件物品放入容量為v的背包中”，
價值為f[i-1][v]；
如果放第i件物品，那么問題就轉化為“前i-1件物品放入剩下的容量為v-c[i]的背包中”，
此時能獲得的最大價值就是f[i-1][v-c[i]]再加上通過放入第i件物品獲得的價值w[i]。
②例題二：
采葯
Time Limit: 1000MS Memory Limit: 65535KB
Submissions: 155 Accepted: 50
Description辰辰是個天資聰穎的孩子，他的夢想是成為世界上最偉大的醫師。為此，他想拜附近最有威望的醫師為師。醫師為了判斷他 的資質，給他出了一個難題。醫師把他帶到一個到處都是草葯的山洞里對他說：“孩子，這個山洞里有一些不同的草葯，采每一株都需要一些時間，每一株也有它自 身的價值。我會給你一段時間，在這段時間里，你可以采到一些草葯。如果你是一個聰明的孩子，你應該可以讓采到的草葯的總價值最大。”
如果你是辰辰，你能完成這個任務嗎？
Input 輸入的第一行有兩個整數T（1 <= T <= 1000）和M（1 <= M <= 100），用一個空格隔開，T代表總共能夠用來采葯的時間，M代表山洞里的草葯的數目。接下來的M行每行包括兩個在1到100之間（包括1和100）的整 數，分別表示采摘某株草葯的時間和這株草葯的價值。
Output輸出包括一行，這一行只包含一個整數，表示在規定的時間內，可以采到的草葯的最大總價值。
Sample Input
70 3
71 100
69 1
1 2
Sample Output
3
View Code
1 #include<iostream> 2 # include<cstring> 3 # define max(a,b) a>b?a:b 4 using namespace std; 5 int main() 6 { 7 8 int dp[101][1001],m,T,w[101],val[101],i,j; 9 cin>>T>>m; 10 for(i=1;i<=m;i++) 11 cin>>w[i]>>val[i]; 12 memset(dp,0,sizeof(dp)); 13 for(i=1;i<=m;i++) 14 for(j=0;j<=T;j++)//j相當於上面說的V-c[i] 15 { 16 if(j>=w[i]) 17 dp[i][j]=max(dp[i-1][j],dp[i-1][j-w[i]]+val[i]);//放還是不放的選擇 18 else dp[i][j]=dp[i-1][j]; 19 } 20 cout<<dp[m][T]<<endl; 21 return 0; 22 }
動態規划解決01背包問題程序:
View Code
1 // 動態規划解決01背包問題 2 #include <iostream> 3 #include <iomanip> 4 //問題描述 五個物體 背包容量W=17 5 //體積數據 v[5]={3,4,7,8,9} 6 //價值數據 w[5]={4,5,10,11,13} 7 using namespace std; 8 void fn(int k,int m); 9 int w[6]={0,4,5,10,11,13};//價值 10 int v[6]={0,3,4,7,8,9};//體積 11 int x[6]; 12 int a[6][18]; 13 int i,j,k,m; 14 int main () 15 { 16 17 //初始化 第0行0列賦值為0 18 for ( i=0;i<=5;i++) a[i][0]=0; 19 for ( j=0;j<=5;j++) a[0][j]=0; 20 21 22 for ( i=1;i<=5;i++) //i表示第幾個物品 23 { for (j=1;j<=17;j++) //j表示容量大小 24 { 25 if (v[i]>j) 26 a[i][j]=a[i-1][j]; 27 else 28 a[i][j]=(a[i-1][j]>a[i-1][j-v[i]]+w[i])? a[i-1][j]:a[i-1][j-v[i]]+w[i]; 29 30 } 31 } 32 //輸出數據表用於觀察 33 for ( i=0;i<=5;i++) //i表示第幾個物品 34 { 35 for (j=0;j<=17;j++) //j表示容量大小 36 { cout<<setw(3)<<a[i][j];} 37 cout<<endl; 38 } 39 40 //找出裝入的物體，輸出到x[] 41 i=5; 42 j=17; 43 while (i>=0&&j>=0) 44 { 45 if (a[i][j]==a[i-1][j]) 46 { 47 x[i]=0; 48 i--; 49 } 50 else 51 { 52 x[i]=1; 53 i--; 54 j=j-v[i]; 55 } 56 } 57 //輸出x[] 58 cout<<endl; 59 for (int i=1;i<=5;i++) 60 cout<<x[i]<<" "; 61 62 return 0; 63 }