背包問題動態規劃python-ag真人国际官网

㈠ 鍔ㄦ佽勫垝奼傝в0-1鑳屽寘闂棰

闅鵑亾鏄鎯寵佺▼搴忥紵

f[i,j]涓哄墠i涓鐗╁搧涓閫夋嫨鑻ュ共涓鏀懼叆浣垮叾浣撶н姝ｅソ涓簀鐨勬爣蹇楋紝涓哄竷灝斿瀷銆
瀹炵幇:灝嗘渶浼樺寲闂棰樿漿鍖栦負鍒ゅ畾鎬ч棶棰
f [i, j] = f [ i-1, j-w[i] ] (w[i]<=j<=v) 杈圭晫錛歠[0,0]:=true.
for i:=1 to n do
for j:=w[i] to v do f[i,j]:=f[i-1,j-w[i]];
浼樺寲錛氬綋鍓嶇姸鎬佸彧涓庡墠涓闃舵電姸鎬佹湁鍏籌紝鍙闄嶈嚦涓緇淬
f[0]:=true;
for i:=1 to n do begin
f1:=f;
for j:=w[i] to v do
if f[j-w[i]] then f1[j]:=true;
f:=f1;
end;

b.奼傚彲浠ユ斁鍏ョ殑鏈澶т環鍊箋
f[i,j] 涓哄歸噺涓篒鏃跺彇鍓峧涓鑳屽寘鎵鑳借幏寰楃殑鏈澶т環鍊箋
f [i,j] = max { f [ i 鈥 w [ j ], j-1] p [ j ], f[ i,j-1] }

c.奼傛伆濂借呮弧鐨勬儏鍐墊暟銆
dp:
procere update;
var j,k:integer;
begin
c:=a;
for j:=0 to n do
if a[j]>0 then
if j now<=n then inc(c[j now],a[j]);
a:=c;
end;

鍦0 / 1鑳屽寘闂棰樹腑錛岄渶瀵瑰歸噺涓篶 鐨勮儗鍖呰繘琛岃呰澆銆備粠n 涓鐗╁搧涓閫夊彇瑁呭叆鑳屽寘鐨勭墿鍝侊紝姣忎歡鐗╁搧i 鐨勯噸閲忎負wi 錛屼環鍊間負pi 銆傚逛簬鍙琛岀殑鑳屽寘瑁呰澆錛岃儗鍖呬腑鐗╁搧鐨勬婚噸閲忎笉鑳借秴榪囪儗鍖呯殑瀹歸噺錛屾渶浣寵呰澆鏄鎸囨墍瑁呭叆鐨勭墿鍝佷環鍊兼渶楂橈紝鍗硃1*x1 p2*x1 ... pi*xi(鍏1<=i<=n錛寈鍙0鎴1錛屽彇1琛ㄧず閫夊彇鐗╁搧i) 鍙栧緱鏈澶у箋
鍦ㄨラ棶棰樹腑闇瑕佸喅瀹歺1 .. xn鐨勫箋傚亣璁炬寜i = 1錛2錛...錛宯 鐨勬″簭鏉ョ『瀹歺i 鐨勫箋傚傛灉緗畑1 = 0錛屽垯闂棰樿漿鍙樹負鐩稿逛簬鍏朵綑鐗╁搧(鍗崇墿鍝2錛3錛.錛宯)錛岃儗鍖呭歸噺浠嶄負c 鐨勮儗鍖呴棶棰樸傝嫢緗畑1 = 1錛岄棶棰樺氨鍙樹負鍏充簬鏈澶ц儗鍖呭歸噺涓篶-w1 鐨勯棶棰樸傜幇璁緍?{c錛宑-w1 } 涓哄墿浣欑殑鑳屽寘瀹歸噺銆
鍦ㄧ涓嬈″喅絳栦箣鍚庯紝鍓╀笅鐨勯棶棰樹究鏄鑰冭檻鑳屽寘瀹歸噺涓簉 鏃剁殑鍐崇瓥銆備笉綆x1 鏄0鎴栨槸1錛孾x2 錛.錛寈n ] 蹇呴』鏄絎涓嬈″喅絳栦箣鍚庣殑涓涓鏈浼樻柟妗堬紝濡傛灉涓嶆槸錛屽垯浼氭湁涓涓鏇村ソ鐨勬柟妗圼y2錛.錛寉n ]錛屽洜鑰孾x1錛寉2錛.錛寉n ]鏄涓涓鏇村ソ鐨勬柟妗堛
鍋囪緉=3, w=[100,14,10], p=[20,18,15], c= 116銆傝嫢璁緓1 = 1錛屽垯鍦ㄦ湰嬈″喅絳栦箣鍚庯紝鍙鐢ㄧ殑鑳屽寘瀹歸噺涓簉= 116-100=16 銆俒x2錛寈3 ]=[0,1] 絎﹀悎瀹歸噺闄愬埗鐨勬潯浠訛紝鎵寰楀間負1 5錛屼絾鍥犱負[x2錛寈3 ]= [1錛0] 鍚屾牱絎﹀悎瀹歸噺鏉′歡涓旀墍寰楀間負1 8錛屽洜姝[x2錛寈3 ] = [ 0錛1] 騫墮潪鏈浼樼瓥鐣ャ傚嵆x= [ 1錛0錛1] 鍙鏀硅繘涓簒= [ 1錛1錛0 ]銆傝嫢璁緓1 = 0錛屽垯瀵逛簬鍓╀笅鐨勪袱縐嶇墿鍝佽岃█錛屽歸噺闄愬埗鏉′歡涓116銆傛諱箣錛屽傛灉瀛愰棶棰樼殑緇撴灉[x2錛寈3 ]涓嶆槸鍓╀綑鎯呭喌涓嬬殑涓涓鏈浼樿в錛屽垯[x1錛寈2錛寈3 ]涔熶笉浼氭槸鎬諱綋鐨勬渶浼樿в銆傚湪姝ら棶棰樹腑錛屾渶浼樺喅絳栧簭鍒楃敱鏈浼樺喅絳栧瓙搴忓垪緇勬垚銆傚亣璁緁 (i,y) 琛ㄧず鍓╀綑瀹歸噺涓簓錛屽墿浣欑墿鍝佷負i錛宨 1錛...錛宯 鏃剁殑鏈浼樿в鐨勫礆紝鍗籌細鍒╃敤鏈浼樺簭鍒楃敱鏈浼樺瓙搴忓垪鏋勬垚鐨勭粨璁猴紝鍙寰楀埌f 鐨勯掑綊寮忎負錛
褰搄>=wi鏃訛細 f(i,j)=max{f(i 1,j),f(i 1,j-wi) vi} 鈶犲紡
褰0<=jfn( 1 ,c) 鏄鍒濆嬫椂鑳屽寘闂棰樼殑鏈浼樿в銆
浠ユ湰棰樹負渚嬶細鑻0鈮y錛1 0錛屽垯f ( 3 ,y) = 0錛涜嫢y鈮1 0錛宖 ( 3 ,y) = 1 5銆傚埄鐢ㄢ憽寮忥紝鍙寰梖 (2, y) = 0 ( 0鈮y錛10 )錛沠(2錛寉)= 1 5(1 0鈮y錛1 4)錛沠(2錛寉)= 1 8(1 4鈮y錛2 4)鍜宖(2錛寉)= 3 3(y鈮2 4)銆傚洜姝ゆ渶浼樿вf ( 1 , 11 6 ) = m a x {f(2錛11 6)錛宖(2錛11 6 - w1) p1} = m a x {f(2錛11 6)錛宖(2錛1 6) 2 0 } = m a x { 3 3錛3 8 } = 3 8銆
鐜板湪璁＄畻xi 鍊礆紝姝ラゅ備笅錛氳嫢f ( 1 ,c) =f ( 2 ,c)錛屽垯x1 = 0錛屽惁鍒檟1 = 1銆傛帴涓嬫潵闇浠庡墿浣欏歸噺c-w1涓瀵繪眰鏈浼樿в錛岀敤f (2, c-w1) 琛ㄧず鏈浼樿в銆備緷姝ょ被鎺錛屽彲寰楀埌鎵鏈夌殑xi (i= 1.n) 鍊箋
鍦ㄨヤ緥涓錛屽彲寰楀嚭f ( 2 , 116 ) = 3 3鈮爁 ( 1 , 11 6 )錛屾墍浠x1 = 1銆傛帴鐫鍒╃敤榪斿洖鍊3 8 -p1=18 璁＄畻x2 鍙妜3錛屾ゆ椂r = 11 6 -w1 = 1 6錛屽張鐢眆 ( 2 , 1 6 ) = 1 8錛屽緱f ( 3 , 1 6 ) = 1 4鈮爁 ( 2 , 1 6 )錛屽洜姝x2 = 1錛屾ゆ椂r= 1 6 -w2 = 2錛屾墍浠f (3,2) =0錛屽嵆寰梮3 = 0銆

㈡ 01背包問題

演算法分析

對於背包問題，通常的處理方法是搜索。
用遞歸來完成搜索，演算法設計如下：
function make( i {處理到第i件物品} , j{剩餘的空間為j}:integer) :integer;
初始時i=m , j=背包總容量
begin
if i:=0 then
make:=0;
if j>=wi then (背包剩餘空間可以放下物品 i )
r1:=make(i-1,j-wi) v; (第i件物品放入所能得到的價值 )
r2:=make(i-1,j)(第i件物品不放所能得到的價值 )
make:=max{r1,r2}
end;
這個演算法的時間復雜度是o(2^n)，我們可以做一些簡單的優化。
由於本題中的所有物品的體積均為整數，經過幾次的選擇後背包的剩餘空間可能會相等，在搜索中會重復計算這些結點，所以，如果我們把搜索過程中計算過的結點的值記錄下來，以保證不重復計算的話，速度就會提高很多。這是簡單?quot;以空間換時間"。
我們發現，由於這些計算過程中會出現重疊的結點，符合動態規劃中子問題重疊的性質。
同時，可以看出如果通過第n次選擇得到的是一個最優解的話，那麼第n-1次選擇的結果一定也是一個最優解。這符合動態規劃中最優子問題的性質。
考慮用動態規劃的方法來解決，這里的：
階段是：在前n件物品中，選取若干件物品放入背包中；
狀態是：在前n件物品中，選取若干件物品放入所剩空間為w的背包中的所能獲得的最大價值；
決策是：第n件物品放或者不放；
由此可以寫出動態轉移方程：
我們用f[i,j]表示在前 i 件物品中選擇若干件放在所剩空間為 j 的背包里所能獲得的最大價值
f[i,j]=max{f[i-1,j-wi] pi (j>=wi), f[i-1,j]}
這個方程非常重要，基本上所有跟背包相關的問題的方程都是由它衍生出來的。所以有必要將它詳細解釋一下：「將前i件物品放入容量為v的背包中」這個子問題，若只考慮第i件物品的策略（放或不放），那麼就可以轉化為一個只牽扯前i-1件物品的問題。如果不放第i件物品，那麼問題就轉化為「前i-1件物品放入容量為v的背包中」，價值為f[v]；如果放第i件物品，那麼問題就轉化為「前i-1件物品放入剩下的容量為v-c的背包中」，此時能獲得的最大價值就是f[v-c]再加上通過放入第i件物品獲得的價值w。
這樣，我們可以自底向上地得出在前m件物品中取出若干件放進背包能獲得的最大價值，也就是f[m,w]
演算法設計如下：
procere make;
begin
for i:=0 to w do
f[0,i]:=0;
for i:=1 to m do
for j:=0 to w do begin
f[i,j]:=f[i-1,j];
if (j>=w) and (f[i-1,j-w] v>f[i,j]) then
f[i,j]:=f[i-1,j-w] v;
end;
writeln(f[m,wt]);
end;
由於是用了一個二重循環，這個演算法的時間復雜度是o（n*w)。而用搜索的時候，當出現最壞的情況，也就是所有的結點都沒有重疊，那麼它的時間復雜度是o（2^n)。看上去前者要快很多。但是，可以發現在搜索中計算過的結點在動態規劃中也全都要計算，而且這里算得更多（有一些在最後沒有派上用場的結點我們也必須計算），在這一點上好像是矛盾的。
事實上，由於我們定下的前提是：所有的結點都沒有重疊。也就是說，任意n件物品的重量相加都不能相等，而所有物品的重量又都是整數，那末這個時候w的最小值是：1 2 2^2 2^3 …… 2^n-1=2^n -1
此時n*w>2^n，動態規劃比搜索還要慢~~|||||||所以，其實背包的總容量w和重疊的結點的個數是有關的。
考慮能不能不計算那些多餘的結點……
優化時間復雜度
以上方法的時間和空間復雜度均為o(n*v)，其中時間復雜度基本已經不能再優化了，但空間復雜度卻可以優化到o(v)。
先考慮上面講的基本思路如何實現，肯定是有一個主循環i=1..n，每次算出來二維數組f[0..v]的所有值。那麼，如果只用一個數組f[0..v]，能不能保證第i次循環結束後f[v]中表示的就是我們定義的狀態f[v]呢？f[v]是由f[v]和f[v-c]兩個子問題遞推而來，能否保證在推f[v]時（也即在第i次主循環中推f[v]時）能夠得到f[v]和f[v-c]的值呢？事實上，這要求在每次主循環中我們以v=v..0的順序推f[v]，這樣才能保證推f[v]時f[v-c]保存的是狀態f[v-c]的值。偽代碼如下：
for i=1..n
for v=v..0
f[v]=max{f[v],f[v-c] w};
其中的f[v]=max{f[v],f[v-c]}一句恰就相當於我們的轉移方程f[v]=max{f[v],f[v-c]}，因為現在的f[v-c]就相當於原來的f[v-c]。如果將v的循環順序從上面的逆序改成順序的話，那麼則成了f[v]由f[v-c]推知，與本題意不符，但它卻是另一個重要的背包問題p02最簡捷的解決方案，故學習只用一維數組解01背包問題是十分必要的。
事實上，使用一維數組解01背包的程序在後面會被多次用到，所以這里抽象出一個處理一件01背包中的物品過程，以後的代碼中直接調用不加說明。
過程zeroonepack，表示處理一件01背包中的物品，兩個參數cost、weight分別表明這件物品的費用和價值。
procere zeroonepack(cost,weight)
for v=v..cost
f[v]=max{f[v],f[v-cost] weight}
注意這個過程里的處理與前面給出的偽代碼有所不同。前面的示常式序寫成v=v..0是為了在程序中體現每個狀態都按照方程求解了，避免不必要的思維復雜度。而這里既然已經抽象成看作黑箱的過程了，就可以加入優化。費用為cost的物品不會影響狀態f[0..cost-1]，這是顯然的。
有了這個過程以後，01背包問題的偽代碼就可以這樣寫：
for i=1..n
zeroonepack(c,w);
初始化的細節問題

我們看到的求最優解的背包問題題目中，事實上有兩種不太相同的問法。有的題目要求「恰好裝滿背包」時的最優解，有的題目則並沒有要求必須把背包裝滿。一種區別這兩種問法的實現方法是在初始化的時候有所不同。
如果是第一種問法，要求恰好裝滿背包，那麼在初始化時除了f[0]為0其它f[1..v]均設為-∞，這樣就可以保證最終得到的f[n]是一種恰好裝滿背包的最優解。
如果並沒有要求必須把背包裝滿，而是只希望價格盡量大，初始化時應該將f[0..v]全部設為0。
為什麼呢？可以這樣理解：初始化的f數組事實上就是在沒有任何物品可以放入背包時的合法狀態。如果要求背包恰好裝滿，那麼此時只有容量為0的背包可能被價值為0的nothing「恰好裝滿」，其它容量的背包均沒有合法的解，屬於未定義的狀態，它們的值就都應該是-∞了。如果背包並非必須被裝滿，那麼任何容量的背包都有一個合法解「什麼都不裝」，這個解的價值為0，所以初始時狀態的值也就全部為0了。
這個小技巧完全可以推廣到其它類型的背包問題，後面也就不再對進行狀態轉移之前的初始化進行講解

㈢ 用動態規劃演算法怎樣求解01背包問題

動態規劃主要解決的是多階段的決策問題。

01背包中，狀態為背包剩餘的容量，階段是每一個物品，決策是是否選擇當前的物品。

所以用動態規劃來解決是非常貼切的。

我們設f[v]表示已經使用容量為v時所能獲得的最大價值，w[i]表示i物品的質量，c[i]表示i物品的價值。

for(inti=1;i<=n;i  )
for(intj=v;j>=w[i];j--)
f[j]=max(f[j],f[j-w[i]] c[i]);

這便是所謂的一個狀態轉移方程。

f[j]表示在已經使用容量為j時的最大價值，f[j-w[i]]表示在已經使用容量為j-w[i]時的最大價值。

f[j]可以由f[j-w[i]]這個狀態轉移到達，表示選取w[i]這個物品，並從而獲得價值為c[i]。

而每次f[j]會在選與不選中決策選出最優的方案。

從每一個物品，也就是每一個階段的局部最優推出最後的全局最優值。這樣就解決了01背包問題

㈣ 0-1背包問題的多種解法代碼（動態規劃、貪心法、回溯法、分支限界法）

一.動態規劃求解0-1背包問題
/************************************************************************/
/* 0-1背包問題：
/* 給定n種物品和一個背包
/* 物品i的重量為wi，其價值為vi
/* 背包的容量為c
/* 應如何選擇裝入背包的物品，使得裝入背包中的物品
/* 的總價值最大？
/* 註：在選擇裝入背包的物品時，對物品i只有兩種選擇，
/* 即裝入或不裝入背包。不能將物品i裝入多次，也
/* 不能只裝入部分的物品i。
/*
/* 1. 0-1背包問題的形式化描述：
/* 給定c>0, wi>0, vi>0, 0<=i<=n，要求找到一個n元的
/* 0-1向量(x1, x2, ..., xn), 使得：
/* max sum_{i=1 to n} (vi*xi),且滿足如下約束：
/* (1) sum_{i=1 to n} (wi*xi) <= c
/* (2) xi∈{0, 1}, 1<=i<=n
/*
/* 2. 0-1背包問題的求解
/* 0-1背包問題具有最優子結構性質和子問題重疊性質，適於
/* 採用動態規劃方法求解
/*
/* 2.1 最優子結構性質
/* 設(y1,y2,...,yn)是給定0-1背包問題的一個最優解，則必有
/* 結論，(y2,y3,...,yn)是如下子問題的一個最優解：
/* max sum_{i=2 to n} (vi*xi)
/* (1) sum_{i=2 to n} (wi*xi) <= c - w1*y1
/* (2) xi∈{0, 1}, 2<=i<=n
/* 因為如若不然，則該子問題存在一個最優解(z2,z3,...,zn)，
/* 而(y2,y3,...,yn)不是其最優解。那麼有：
/* sum_{i=2 to n} (vi*zi) > sum_{i=2 to n} (vi*yi)
/* 且，w1*y1 sum_{i=2 to n} (wi*zi) <= c
/* 進一步有：
/* v1*y1 sum_{i=2 to n} (vi*zi) > sum_{i=1 to n} (vi*yi)
/* w1*y1 sum_{i=2 to n} (wi*zi) <= c
/* 這說明：(y1,z2,z3,...zn)是所給0-1背包問題的更優解，那麼
/* 說明(y1,y2,...,yn)不是問題的最優解，與前提矛盾，所以最優
/* 子結構性質成立。
/*
/* 2.2 子問題重疊性質
/* 設所給0-1背包問題的子問題 p(i,j)為：
/* max sum_{k=i to n} (vk*xk)
/* (1) sum_{k=i to n} (wk*xk) <= j
/* (2) xk∈{0, 1}, i<=k<=n
/* 問題p(i,j)是背包容量為j、可選物品為i,i 1,...,n時的子問題
/* 設m(i,j)是子問題p(i,j)的最優值，即最大總價值。則根據最優
/* 子結構性質，可以建立m(i,j)的遞歸式：
/* a. 遞歸初始 m(n,j)
/* //背包容量為j、可選物品只有n，若背包容量j大於物品n的
/* //重量，則直接裝入；否則無法裝入。
/* m(n,j) = vn, j>=wn
/* m(n,j) = 0, 0<=j/* b. 遞歸式 m(i,j)
/* //背包容量為j、可選物品為i,i 1,...,n
/* //如果背包容量j/* m(i,j) = m(i 1,j), 0<=j/* //如果j>=wi，則在不裝物品i和裝入物品i之間做出選擇
/* 不裝物品i的最優值：m(i 1,j)
/* 裝入物品i的最優值：m(i 1, j-wi) vi
/* 所以：
/* m(i,j) = max {m(i 1,j), m(i 1, j-wi) vi}, j>=wi
/*
/************************************************************************/

#define max(a,b) (((a) > (b)) ? (a) : (b))
#define min(a,b) (((a) < (b)) ? (a) : (b))
template
void knapsack(type* v, int *w, int c, int n, type **m)
{
//遞歸初始條件
int jmax = min(w[n] - 1, c);
for (int j=0; j<=jmax; j ) {
m[n][j] = 0;
}

for (j=w[n]; j<=c; j ) {
m[n][j] = v[n];
}

//i從2到n-1，分別對j>=wi和0<=j for (int i=n-1; i>1; i--) {
jmax = min(w[i] - 1, c);
for (int j=0; j<=jmax; j ) {
m[i][j] = m[i 1][j];
}
for (j=w[i]; j<=c; j ) {
m[i][j] = max(m[i 1][j], m[i 1][j-w[i]] v[i]);
}
}

m[1][c] = m[2][c];
if (c >= w[1]) {
m[1][c] = max(m[1][c], m[2][c-w[1]] v[1]);
}

}

template
void traceback(type **m, int *w, int c, int n, int* x)
{
for (int i=1; i if(m[i][c] == m[i 1][c]) x[i] = 0;
else {
x[i] = 1;
c -= w[i];
}
}
x[n] = (m[n][c])? 1:0;
}

int main(int argc, char* argv[])
{
int n = 5;
int w[6] = {-1, 2, 2, 6, 5, 4};
int v[6] = {-1, 6, 3, 5, 4, 6};
int c = 10;

int **ppm = new int*[n 1];
for (int i=0; i ppm[i] = new int[c 1];
}

int x[6];

knapsack(v, w, c, n, ppm);
traceback(ppm, w, c, n, x);

return 0;
}
二.貪心演算法求解0-1背包問題
1.貪心法的基本思路：
——從問題的某一個初始解出發逐步逼近給定的目標，以盡可能快的地求得更好的解。當達到某演算法中的某一步不能再繼續前進時，演算法停止。
該演算法存在問題：
1).不能保證求得的最後解是最佳的；
2).不能用來求最大或最小解問題；
3).只能求滿足某些約束條件的可行解的范圍。

實現該演算法的過程：
從問題的某一初始解出發；
while 能朝給定總目標前進一步 do
求出可行解的一個解元素；
由所有解元素組合成問題的一個可行解；

2.例題分析

1).[背包問題]有一個背包，背包容量是m=150。有7個物品，物品可以分割成任意大小。
要求盡可能讓裝入背包中的物品總價值最大，但不能超過總容量。

物品 a b c d e f g
重量 35 30 60 50 40 10 25
價值 10 40 30 50 35 40 30

分析：
目標函數： ∑pi最大
約束條件是裝入的物品總重量不超過背包容量：∑wi<=m( m=150)
（1）根據貪心的策略，每次挑選價值最大的物品裝入背包，得到的結果是否最優？
（2）每次挑選所佔空間最小的物品裝入是否能得到最優解？
（3）每次選取單位容量價值最大的物品，成為解本題的策略。

<程序代碼:>(環境:c )
#include
#define max 100 //最多物品數
void sort (int n,float a[max],float b[max]) //按價值密度排序
{
int j,h,k;
float t1,t2,t3,c[max];
for(k=1;k<=n;k )
c[k]=a[k]/b[k];
for(h=1;hfor(j=1;j<=n-h;j )
if(c[j]{t1=a[j];a[j]=a[j 1];a[j 1]=t1;
t2=b[j];b[j]=b[j 1];b[j 1]=t2;
t3=c[j];c[j]=c[j 1];c[j 1]=t3;
}
}
void knapsack(int n,float limitw,float v[max],float w[max],int x[max])
{float c1; //c1為背包剩餘可裝載重量
int i;
sort(n,v,w); //物品按價值密度排序
c1=limitw;
for(i=1;i<=n;i )
{
if(w[i]>c1)break;
x[i]=1; //x[i]為1時，物品i在解中
c1=c1-w[i];
}
}
void main()
{int n,i,x[max];
float v[max],w[max],totalv=0,totalw=0,limitw;
cout<<"請輸入n和limitw:";
cin>>n >>limitw;
for(i=1;i<=n;i )
x[i]=0; //物品選擇情況表初始化為0
cout<<"請依次輸入物品的價值："<for(i=1;i<=n;i )
cin>>v[i];
cout<cout<<"請依次輸入物品的重量："<for(i=1;i<=n;i )
cin>>w[i];
cout<knapsack (n,limitw,v,w,x);
cout<<"the selection is:";
for(i=1;i<=n;i )
{
cout<if(x[i]==1)
totalw=totalw w[i];
}
cout<cout<<"背包的總重量為："<cout<<"背包的總價值為："<}
三.回溯演算法求解0-1背包問題
1.0-l背包問題是子集選取問題。
一般情況下，0-1背包問題是np難題。0-1背包
問題的解空間可用子集樹表示。解0-1背包問題的回溯法與裝載問題的回溯法十分類
似。在搜索解空間樹時，只要其左兒子結點是一個可行結點，搜索就進入其左子樹。當
右子樹有可能包含最優解時才進入右子樹搜索。否則將右子樹剪去。設r是當前剩餘
物品價值總和；cp是當前價值；bestp是當前最優價值。當cp r≤bestp時，可剪去右
子樹。計算右子樹中解的上界的更好方法是將剩餘物品依其單位重量價值排序，然後
依次裝入物品，直至裝不下時，再裝入該物品的一部分而裝滿背包。由此得到的價值是
右子樹中解的上界。
2.解決辦法思路：
為了便於計算上界，可先將物品依其單位重量價值從大到小排序，此後只要順序考
察各物品即可。在實現時，由bound計算當前結點處的上界。在搜索解空間樹時，只要其左兒子節點是一個可行結點，搜索就進入左子樹，在右子樹中有可能包含最優解是才進入右子樹搜索。否則將右子樹剪去。

回溯法是一個既帶有系統性又帶有跳躍性的的搜索演算法。它在包含問題的所有解的解空間樹中，按照深度優先的策略，從根結點出發搜索解空間樹。演算法搜索至解空間樹的任一結點時，總是先判斷該結點是否肯定不包含問題的解。如果肯定不包含，則跳過對以該結點為根的子樹的系統搜索，逐層向其祖先結點回溯。否則，進入該子樹，繼續按深度優先的策略進行搜索。回溯法在用來求問題的所有解時，要回溯到根，且根結點的所有子樹都已被搜索遍才結束。而回溯法在用來求問題的任一解時，只要搜索到問題的一個解就可以結束。這種以深度優先的方式系統地搜索問題的解的演算法稱為回溯法，它適用於解一些組合數較大的問題。
2.演算法框架：
a.問題的解空間：應用回溯法解問題時，首先應明確定義問題的解空間。問題的解空間應到少包含問題的一個（最優）解。
b.回溯法的基本思想：確定了解空間的組織結構後，回溯法就從開始結點（根結點）出發，以深度優先的方式搜索整個解空間。這個開始結點就成為一個活結點，同時也成為當前的擴展結點。在當前的擴展結點處，搜索向縱深方向移至一個新結點。這個新結點就成為一個新的活結點，並成為當前擴展結點。如果在當前的擴展結點處不能再向縱深方向移動，則當前擴展結點就成為死結點。換句話說，這個結點不再是一個活結點。此時，應往回移動（回溯）至最近的一個活結點處，並使這個活結點成為當前的擴展結點。回溯法即以這種工作方式遞歸地在解空間中搜索，直至找到所要求的解或解空間中已沒有活結點時為止。
3.運用回溯法解題通常包含以下三個步驟：
a.針對所給問題，定義問題的解空間；
b.確定易於搜索的解空間結構；
c.以深度優先的方式搜索解空間，並且在搜索過程中用剪枝函數避免無效搜索；
#include

using namespace std;

class knap
{
friend int knapsack(int p[],int w[],int c,int n );

public:
void print()
{

for(int m=1;m<=n;m )
{
cout< }
cout<};

private:
int bound(int i);
void backtrack(int i);

int c;//背包容量
int n; //物品數
int *w;//物品重量數組
int *p;//物品價值數組
int cw;//當前重量
int cp;//當前價值
int bestp;//當前最優值
int *bestx;//當前最優解
int *x;//當前解

};

int knap::bound(int i)
{
//計算上界
int cleft=c-cw;//剩餘容量
int b=cp;
//以物品單位重量價值遞減序裝入物品
while(i<=n&&w[i]<=cleft)
{
cleft-=w[i];
b =p[i];
i ;
}
//裝滿背包
if(i<=n)
b =p[i]/w[i]*cleft;
return b;
}

void knap::backtrack(int i)
{
if(i>n)
{
if(bestp{
for(int j=1;j<=n;j )
bestx[j]=x[j];
bestp=cp;
}
return;
}
if(cw w[i]<=c) //搜索左子樹
{
x[i]=1;
cw =w[i];
cp =p[i];
backtrack(i 1);
cw-=w[i];
cp-=p[i];
}
if(bound(i 1)>bestp)//搜索右子樹
{
x[i]=0;
backtrack(i 1);
}

}

class object
{
friend int knapsack(int p[],int w[],int c,int n);
public:
int operator<=(object a)const
{
return (d>=a.d);
}

private:
int id;
float d;
};

int knapsack(int p[],int w[],int c,int n)
{
//為knap::backtrack初始化
int w=0;
int p=0;
int i=1;
object *q=new object[n];
for(i=1;i<=n;i )
{
q[i-1].id=i;
q[i-1].d=1.0*p[i]/w[i];
p =p[i];
w =w[i];
}
if(w<=c)
return p;//裝入所有物品
//依物品單位重量排序
float f;
for( i=0;ifor(int j=i;j{
if(q[i].d {
f=q[i].d;
q[i].d=q[j].d;
q[j].d=f;
}

}

knap k;
k.p = new int[n 1];
k.w = new int[n 1];
k.x = new int[n 1];
k.bestx = new int[n 1];
k.x[0]=0;
k.bestx[0]=0;
for( i=1;i<=n;i )
{
k.p[i]=p[q[i-1].id];
k.w[i]=w[q[i-1].id];
}
k.cp=0;
k.cw=0;
k.c=c;
k.n=n;
k.bestp=0;
//回溯搜索
k.backtrack(1);
k.print();
delete [] q;
delete [] k.w;
delete [] k.p;
return k.bestp;

}

void main()
{
int *p;
int *w;
int c=0;
int n=0;
int i=0;
char k;
cout<<"0-1背包問題——回溯法 "<cout<<" by zbqplayer "<while(k)
{
cout<<"請輸入背包容量(c)："<cin>>c;
cout<<"請輸入物品的個數(n)："< cin>>n;
p=new int[n 1];
w=new int[n 1];
p[0]=0;
w[0]=0;

cout<<"請輸入物品的價值(p)："<for(i=1;i<=n;i )
cin>>p[i];

cout<<"請輸入物品的重量(w)："<for(i=1;i<=n;i )
cin>>w[i];

cout<<"最優解為(bestx)："<cout<<"最優值為(bestp)："<cout< cout<<"[s] 重新開始"<cout<<"[q] 退出"<cin>>k;
}
四.分支限界法求解0-1背包問題
1.問題描述：已知有n個物品和一個可以容納m重量的背包，每種物品i的重量為weight，一個只能全放入或者不放入，求解如何放入物品，可以使背包里的物品的總效益最大。

2.設計思想與分析：對物品的選取與否構成一棵解樹，左子樹表示不裝入，右表示裝入，通過檢索問題的解樹得出最優解，並用結點上界殺死不符合要求的結點。

#include

struct good
{
int weight;
int benefit;
int flag;//是否可以裝入標記
};

int number=0;//物品數量
int upbound=0;
int curp=0, curw=0;//當前效益值與重量
int maxweight=0;
good *bag=null;

void init_good()
{
bag=new good [number];

for(int i=0; i{
cout<<"請輸入第件"<cin>>bag[i].weight;
cout<<"請輸入第件"<cin>>bag[i].benefit;
bag[i].flag=0;//初始標志為不裝入背包
cout<}

}

int getbound(int num, int *bound_u)//返回本結點的c限界和u限界
{
for(int w=curw, p=curp; num{
w=w bag[num].weight;
p=w bag[num].benefit;
}

*bound_u=p bag[num].benefit;
return ( p bag[num].benefit*((maxweight-w)/bag[num].weight) );
}

void lcbag()
{
int bound_u=0, bound_c=0;//當前結點的c限界和u限界

for(int i=0; i{
if( ( bound_c=getbound(i 1, &bound_u) )>upbound )//遍歷左子樹
upbound=bound_u;//更改已有u限界,不更改標志

if( getbound(i, &bound_u)>bound_c )//遍歷右子樹
//若裝入，判斷右子樹的c限界是否大於左子樹根的c限界，是則裝入
{
upbound=bound_u;//更改已有u限界
curp=curp bag[i].benefit;
curw=curw bag[i].weight;//從已有重量和效益加上新物品
bag[i].flag=1;//標記為裝入
}
}

}

void display()
{

cout<<"可以放入背包的物品的編號為：";
for(int i=0; iif(bag[i].flag>0)
cout<cout<delete []bag;
}