背包问题的求解：
\u80cc\u5305\u95ee\u9898\u7684\u6c42\u89e3#include
using namespace std;
struct bag{
double w;
double p;
double p_w;
int order;
}; //\u8bf4\u660e\u7269\u54c1\u7279\u6027
void sort(struct bag *a,int low,int high);
int main()
{
int n,i;
double *x; //\u89e3\u5411\u91cf\uff0c\u7531\u4e8e\u4e66\u6570\u7ec4\uff0c\u62ff\u6307\u9488\u8868\u793a
double m,cost=0;
struct bag *b; //\u7ed3\u6784\u6570\u7ec4\uff0c\u7528\u4e8e\u8868\u793a\u6240\u6709\u7269\u54c1
//\u5b9a\u4e49\u6587\u4ef6\u6d41\u5e76\u4e0e\u5177\u4f53\u7684\u78c1\u76d8\u6587\u4ef6\u76f8\u5173\u8054
ifstream fin;
fin.open("\u80cc\u5305\u95ee\u9898_in.txt");
ofstream fout;
fout.open("\u80cc\u5305\u95ee\u9898_out.txt");
//\u8f93\u5165\u7269\u54c1\u6570\u76ee n \u80cc\u5305\u5bb9\u91cf M
fin>>n>>m;
//\u52a8\u6001\u5206\u914d\u5b58\u50a8\u7a7a\u95f4
b=new struct bag[n];
x=new double[n];
for(i=0;i<n;i++){
fin>>b[i].w>>b[i].p; //\u8f93\u5165\u7269\u54c1\u91cd\u91cf\u548c\u8fd0\u4ef7
b[i].p_w=b[i].p/b[i].w; //\u6c42\u51fa\u8fd0\u4ef7\u91cd\u91cf\u6bd4
b[i].order=i; //\u8d34\u6807\u7b7e
}
sort(b,0,n-1); //\u6309\u8fd0\u4ef7\u91cd\u91cf\u6bd4\u4ece\u5927\u5230\u5c0f\u8fdb\u884c\u6392\u5e8f
for(i=0;i<n;i++)
x[i]=0; //\u521d\u59cb\u5316\u89e3\u5411\u91cf
for(i=0;i<n;i++) //\u5904\u7406\u6240\u6709\u7269\u54c1
if(b[i].w<=m){ //\u82e5\u80cc\u5305\u80fd\u653e\u5f97\u4e0b\u6574\u4e2a\u7269\u54c1
x[b[i].order]=1; //\u653e\u5165\u80cc\u5305
m-=b[i].w; //\u80cc\u5305\u5269\u4f59\u5bb9\u91cf\u51cf\u5c0f
cost+=b[i].p; //\u603b\u4ef7\u503c\u589e\u52a0
}
else{ //\u5426\u5219\uff0c\u653e\u4e0d\u4e0b\u6574\u4e2a\u7269\u54c1
x[b[i].order]=m/b[i].w; //\u653e\u4e00\u90e8\u5206
cost+=x[b[i].order]*b[i].p; //\u603b\u4ef7\u503c\u589e\u52a0
break; //\u6253\u65ad\uff0c\u540e\u7eed\u7269\u54c1\u7531\u4e8e\u4e0d\u80fd\u653e\u5165\u80cc\u5305\uff0c\u4e0d\u9700\u5904\u7406
}
for(i=0;i<n;i++)
fout<<x[i]<<"\t"; //\u8f93\u51fa\u89e3\u5411\u91cf
fout<<endl<<cost;
//\u5220\u9664\u52a8\u6001\u5206\u914d\u4e0b\u7684\u7a7a\u95f4
delete []x;
delete []b;
//\u5173\u95ed\u6587\u4ef6\u6307\u9488
fin.close();
fout.close();
return 0;
}
int par(struct bag *a,int low,int high)
{
struct bag temp;
temp=a[low];
double t;
t=a[low].p_w;
while(low<high){
while(low<high && a[high].p_w<=t)
--high;
a[low]=a[high];
while(low=t)
++low;
a[high]=a[low];
}
a[low]=temp;
return low;
}
void sort(struct bag *a,int low,int high)
{
int loc;
if(low<high){
loc=par(a,low,high);
sort(a,low,loc-1);
sort(a,loc+1,high);
}
}
...=\u3002=
\u8fd9\u4e2a\u53ef\u63b0\u7684\u771f\u591f\u7ec6\u7684..
\u592a\u7ec6\u4e86\u53cd\u800c\u5bf9\u4f60\u6ca1\u597d\u5904\uff0c\u7b97\u6cd5\u8fd9\u4e1c\u897f\u662f\u8981\u9760\u81ea\u5df1\u53bb\u591a\u60f3\u7684\uff01
\u591a\u505a\u9898\uff0c\u591a\u601d\u8003\u3002\u4f60\u662f\u641eOI\u7684\u4e0d\uff1f\u770b\u8fc7DD\u5927\u725b\u7684\u80cc\u5305\u4e5d\u8bb2\u6ca1\u6709\uff1f
\u4f60\u8981\u5148\u641e\u6e05\u57fa\u7840\u7684\uff0c\u641e\u6e05\u601d\u8def\u3002\u81f3\u4e8e\u5b9e\u73b0\uff0c\u4e0d\u8981\u8f7b\u6613\u53bb\u770b\u522b\u4eba\u7684\u4ee3\u7801\uff0c\u8981\u81ea\u5df1\u5199\u3002\u8981\u662f\u5b9e\u5728\u5199\u4e0d\u51fa\u6765\uff0c\u624d\u53bb\u770b\u3002\u5f53\u7136\u81f3\u4e8e\u4ec0\u4e48\u7a0b\u5ea6\u53eb\u505a\u5b9e\u5728\u5199\u4e0d\u51fa\u6765\uff0c\u5c31\u8981\u770b\u4f60\u5bf9\u81ea\u5df1\u7684\u4e25\u683c\u7a0b\u5ea6\u4e86\u3002
\u6211\u8bb0\u5f97\u6211\u5f53\u521d\u7684\u65f6\u5019\u662f\u5750\u8f66\u5403\u996d\u90fd\u5728\u7406\u89e3\u601d\u8def\uff0c\u60f3\u5b9e\u73b0\u65b9\u5f0f\u3002
用登山算法求解背包问题 function []=DengShan(n,G,P,W) %n是背包的个数，G是背包的总容量，P是价值向量，W是物体的重量向量 %n=3;G=20;P=[25,24,15];W2=[18,15,10];%输入量 W2=W; [Y,I]=sort(-P./W2);W1=[];X=[];X1=[]; for i=1:length(I) W1(i)=W2(I(i)); end W=W1; for i=1:n X(i)=0; RES=G;%背包的剩余容量 j=1; while W(j)<=RES X(j)=1; RES=RES-W(j); j=j+1; end X(j)=RES/W(j); end for i=1:length(I) X1(I(i))=X(i); end X=X1; disp('装包的方法是');disp(X);disp(X.*W2);disp('总的价值是：');disp(P*X');
时间复杂度是非指数的
2)递归法
先看完全背包问题
一个旅行者有一个最多能用m公斤的背包，现在有n种物品，每件的重量分别是W1，W2，...,Wn,
每件的价值分别为C1,C2,...,Cn.若的每种物品的件数足够多.
求旅行者能获得的最大总价值。
本问题的数学模型如下：
设 f(x)表示重量不超过x公斤的最大价值，
则 f(x）=max{f(x-i)+c[i]} 当x>=w[i] 1<=i<=n
可使用递归法解决问题程序如下:
program knapsack04;
const maxm=200;maxn=30;
type ar=array[0..maxn] of integer;
var m,n,j,i,t:integer;
c,w:ar;
function f(x:integer):integer;
var i,t,m:integer;
begin
if x=0 then f:=0 else
begin
t:=-1;
for i:=1 to n do
begin
if x>=w[i] then m:=f(x-i)+c[i];
if m>t then t:=m;
end;
f:=t;
end;
end;
begin
readln(m,n);
for i:= 1 to n do
readln(w[i],c[i]);
writeln(f(m));
end.
说明:当m不大时,编程很简单,但当m较大时,容易超时.
4.2 改进的递归法
改进的的递归法的思想还是以空间换时间,这只要将递归函数计算过程中的各个子函数的值保存起来,开辟一个
一维数组即可
程序如下:
program knapsack04;
const maxm=2000;maxn=30;
type ar=array[0..maxn] of integer;
var m,n,j,i,t:integer;
c,w:ar;
p:array[0..maxm] of integer;
function f(x:integer):integer;
var i,t,m:integer;
begin
if p[x]<>-1 then f:=p[x]
else
begin
if x=0 then p[x]:=0 else
begin
t:=-1;
for i:=1 to n do
begin
if x>=w[i] then m:=f(i-w[i])+c[i];
if m>t then t:=m;
end;
p[x]:=t;
end;
f:=p[x];
end;
end;
begin
readln(m,n);
for i:= 1 to n do
readln(w[i],c[i]);
fillchar(p,sizeof(p),-1);
writeln(f(m));
end.
3)贪婪算法
改进的背包问题：给定一个超递增序列和一个背包的容量，然后在超递增序列中选（只能选一次）或不选每一个数值，使得选中的数值的和正好等于背包的容量。
代码思路：从最大的元素开始遍历超递增序列中的每个元素，若背包还有大于或等于当前元素值的空间，则放入，然后继续判断下一个元素；若背包剩余空间小于当前元素值，则判断下一个元素
简单模拟如下：
#define K 10
#define N 10
＃i nclude <stdlib.h>
＃i nclude <conio.h>
void create(long array[],int n,int k)
{/*产生超递增序列*/
int i,j;
array[0]=1;
for(i=1;i<n;i++)
{
long t=0;
for(j=0;j<i;j++)
t=t+array[j];
array[i]=t+random(k)+1;
}
}
void output(long array[],int n)
{/*输出当前的超递增序列*/
int i;
for(i=0;i<n;i++)
{
if(i%5==0)
printf("\n");
printf("%14ld",array[i]);
}
}
void beibao(long array[],int cankao[],long value,int count)
{/*背包问题求解*/
int i;
long r=value;
for(i=count-1;i>=0;i--)/*遍历超递增序列中的每个元素*/
{
if(r>=array[i])/*如果当前元素还可以放入背包，即背包剩余空间还大于当前元素*/
{
r=r-array[i];
cankao[i]=1;
}
else/*背包剩余空间小于当前元素值*/
cankao[i]=0;
}
}
void main()
{
long array[N];
int cankao[N]={0};
int i;
long value,value1=0;
clrscr();
create(array,N,K);
output(array,N);
printf("\nInput the value of beibao:\n");
scanf("%ld",&value);
beibao(array,cankao,value,N);
for(i=0;i<N;i++)/*所有已经选中的元素之和*/
if(cankao[i]==1)
value1+=array[i];
if(value==value1)
{
printf("\nWe have got a solution,that is:\n");
for(i=0;i<N;i++)
if(cankao[i]==1)
{
if(i%5==0)
printf("\n");
printf("%13ld",array[i]);
}
}
else
printf("\nSorry.We have not got a solution.\n");
}
贪婪算法的另一种写法，beibao函数是以前的代码，用来比较两种算法：
#define K 10
#define N 10
＃i nclude <stdlib.h>
＃i nclude <conio.h>
void create(long array[],int n,int k)
{
int i,j;
array[0]=1;
for(i=1;i<n;i++)
{
long t=0;
for(j=0;j<i;j++)
t=t+array[j];
array[i]=t+random(k)+1;
}
}
void output(long array[],int n)
{
int i;
for(i=0;i<n;i++)
{
if(i%5==0)
printf("\n");
printf("%14ld",array[i]);
}
}
void beibao(long array[],int cankao[],long value,int count)
{
int i;
long r=value;
for(i=count-1;i>=0;i--)
{
if(r>=array[i])
{
r=r-array[i];
cankao[i]=1;
}
else
cankao[i]=0;
}
}
int beibao1(long array[],int cankao[],long value,int n)
{/*贪婪算法*/
int i;
long value1=0;
for(i=n-1;i>=0;i--)/*先放大的物体，再考虑小的物体*/
if((value1+array[i])<=value)/*如果当前物体可以放入*/
{
cankao[i]=1;/*1表示放入*/
value1+=array[i];/*背包剩余容量减少*/
}
else
cankao[i]=0;
if(value1==value)
return 1;
return 0;
}
void main()
{
long array[N];
int cankao[N]={0};
int cankao1[N]={0};
int i;
long value,value1=0;
clrscr();
create(array,N,K);
output(array,N);
printf("\nInput the value of beibao:\n");
scanf("%ld",&value);
beibao(array,cankao,value,N);
for(i=0;i<N;i++)
if(cankao[i]==1)
value1+=array[i];
if(value==value1)
{
printf("\nWe have got a solution,that is:\n");
for(i=0;i<N;i++)
if(cankao[i]==1)
{
if(i%5==0)
printf("\n");
printf("%13ld",array[i]);
}
}
else
printf("\nSorry.We have not got a solution.\n");
printf("\nSecond method:\n");
if(beibao1(array,cankao1,value,N)==1)
{
for(i=0;i<N;i++)
if(cankao1[i]==1)
{
if(i%5==0)
printf("\n");
printf("%13ld",array[i]);
}
}
else
printf("\nSorry.We have not got a solution.\n");
}
4)动态规划算法
解决0/1背包问题的方法有多种，最常用的有贪婪法和动态规划法。其中贪婪法无法得到问题的最优解，而动态规划法都可以得到最优解，下面是用动态规划法来解决0/1背包问题。
动态规划算法与分治法类似，其基本思想是将待求解问题分解成若干个子问题，然后从这些子问题的解得到原问题的解。与分治法不同的是，适合于用动态规划法求解的问题，经分解得到的子问题往往不是互相独立的，若用分治法解这类问题，则分解得到的子问题数目太多，以至于最后解决原问题需要耗费过多的时间。动态规划法又和贪婪算法有些一样，在动态规划中，可将一个问题的解决方案视为一系列决策的结果。不同的是，在贪婪算法中，每采用一次贪婪准则便做出一个不可撤回的决策，而在动态规划中，还要考察每个最优决策序列中是否包含一个最优子序列。
0/1背包问题
在0 / 1背包问题中，需对容量为c 的背包进行装载。从n 个物品中选取装入背包的物品，每件物品i 的重量为wi ，价值为pi 。对于可行的背包装载，背包中物品的总重量不能超过背包的容量，最佳装载是指所装入的物品价值最高，即p1*x1+p2*x1+...+pi*xi(其1<=i<=n，x取0或1，取1表示选取物品i) 取得最大值。
在该问题中需要决定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 ] 必须是第一次决策之后的一个最优方案，如果不是，则会有一个更好的方案[y2，.，yn ]，因而[x1，y2，.，yn ]是一个更好的方案。
假设n=3, w=[100,14,10], p=[20,18,15], c= 116。若设x1 = 1，则在本次决策之后，可用的背包容量为r= 116-100=16 。[x2，x3 ]=[0,1] 符合容量限制的条件，所得值为1 5，但因为[x2，x3 ]= [1，0] 同样符合容量条件且所得值为1 8，因此[x2，x3 ] = [ 0，1] 并非最优策略。即x= [ 1，0，1] 可改进为x= [ 1，1，0 ]。若设x1 = 0，则对于剩下的两种物品而言，容量限制条件为116。总之，如果子问题的结果[x2，x3 ]不是剩余情况下的一个最优解，则[x1，x2，x3 ]也不会是总体的最优解。在此问题中，最优决策序列由最优决策子序列组成。假设f (i,y) 表示剩余容量为y，剩余物品为i，i + 1，...，n 时的最优解的值，即：利用最优序列由最优子序列构成的结论，可得到f 的递归式为：
当j>=wi时： f(i,j)=max{f(i+1,j),f(i+1,j-wi)+vi} ①式
当0<=j<wi时：f(i,j)=f(i+1,j) ②式
fn( 1 ,c) 是初始时背包问题的最优解。
以本题为例：若0≤y＜1 0，则f ( 3 ,y) = 0；若y≥1 0，f ( 3 ,y) = 1 5。利用②式，可得f (2, y) = 0 ( 0≤y＜10 )；f(2，y)= 1 5(1 0≤y＜1 4)；f(2，y)= 1 8(1 4≤y＜2 4)和f(2，y)= 3 3(y≥2 4)。因此最优解f ( 1 , 11 6 ) = m a x {f(2，11 6)，f(2，11 6 - w1)+ p1} = m a x {f(2，11 6)，f(2，1 6)+ 2 0 } = m a x { 3 3，3 8 } = 3 8。
现在计算xi 值，步骤如下：若f ( 1 ,c) =f ( 2 ,c)，则x1 = 0，否则x1 = 1。接下来需从剩余容量c-w1中寻求最优解，用f (2, c-w1) 表示最优解。依此类推，可得到所有的xi (i= 1.n) 值。
在该例中，可得出f ( 2 , 116 ) = 3 3≠f ( 1 , 11 6 )，所以x1 = 1。接着利用返回值3 8 -p1=18 计算x2 及x3，此时r = 11 6 -w1 = 1 6，又由f ( 2 , 1 6 ) = 1 8，得f ( 3 , 1 6 ) = 1 4≠f ( 2 , 1 6 )，因此x2 = 1，此时r= 1 6 -w2 = 2，所以f (3,2) =0，即得x3 = 0。
绛旓細0-1鑳屽寘闂 鏄緝涓虹畝鍗曠殑鍔ㄦ佽鍒掗棶棰橈紝涔熸槸鍏朵粬鑳屽寘闂鐨勫熀纭銆傚姩鎬佽鍒掓槸涓嶆柇鍐崇瓥姹傛渶浼樿В鐨勮繃绋嬶紝 0-1鑳屽寘闂 鍗虫槸涓嶆柇瀵圭i涓墿鍝佸仛鍑哄喅绛栵紝 0-1 灏辨槸浠ｈ〃閫夋嫨鎴栬呬笉閫夋嫨涓ょ鍐冲畾銆
绛旓細闂鎻忚堪锛 鏈塶浠剁墿鍝佸拰瀹归噺涓簃鐨勮儗鍖 缁欏嚭i浠剁墿鍝佺殑閲嶉噺浠ュ強浠峰 杩樻湁鏁伴噺 姹傝В璁╄鍏ヨ儗鍖呯殑鐗╁搧閲嶉噺涓嶈秴杩囪儗鍖呭閲 涓斾环鍊兼渶澶 銆 鐗圭偣 锛 瀹冧笌瀹屽叏鑳屽寘鏈夌被浼肩偣 鐗圭偣鏄瘡涓墿鍝侀兘鏈変簡 涓瀹氱殑鏁伴噺 銆傜姸鎬佽浆绉绘柟绋嬩负锛 f[j] = max{f[j], f[j−k∗a[i]]+k∗b[...
绛旓細鐢ㄧ櫥灞辩畻娉曟眰瑙ｈ儗鍖呴棶棰 function []=DengShan(n,G,P,W) %n鏄儗鍖呯殑涓暟,G鏄儗鍖呯殑鎬诲閲,P鏄环鍊煎悜閲,W鏄墿浣撶殑閲嶉噺鍚戦噺 %n=3;G=20;P=[25,24,15];W2=[18,15,10];%杈撳叆閲 W2=W; [Y,I]=sort(-P./W2);W1=[];X=[];X1=[]; for i=1:length(I) W1(i)=W2(I(i)); end W=W1;...
绛旓細杩欒窡01鑳屽寘闂涓鏍锋湁O(N*V)涓姸鎬侀渶瑕姹傝В锛屼絾姹傝В姣忎釜鐘舵佺殑鏃堕棿鍒欎笉鏄父鏁颁簡锛屾眰瑙ｇ姸鎬乫[i][v]鐨勬椂闂存槸O(v/c[i])锛屾荤殑澶嶆潅搴︽槸瓒呰繃O(VN)鐨勩傚皢01鑳屽寘闂鐨鍩烘湰鎬濊矾鍔犱互鏀硅繘锛屽緱鍒颁簡杩欐牱涓涓竻鏅扮殑鏂规硶銆傝繖璇存槑01鑳屽寘闂鐨勬柟绋嬬殑纭槸寰堥噸瑕侊紝鍙互鎺ㄥ強鍏跺畠绫诲瀷鐨勮儗鍖呴棶棰樸備絾鎴戜滑杩樻槸璇曞浘...
绛旓細0-1鑳屽寘闂璇寸殑鏄紝缁欏畾鑳屽寘瀹归噺W锛屼竴绯诲垪鐗╁搧{weiht,value}锛屾瘡涓墿鍝佸彧鑳藉彇涓浠讹紝鑾峰彇鏈澶у笺閲囩敤鍔ㄦ佽鍒掓眰瑙锛屽姩鎬佽鍒掔殑涓鑸寰嬮兘鏄紝鍦ㄤ粈涔堜粈涔堝墠i涓姸鎬佷笅鐨勬渶澶у兼垨鑰呮渶灏忓肩殑鍓嶆彁涓嬶紝鐒跺悗鍐嶆妸i鐨勭姸鎬佺殑鍊兼眰鍑烘潵銆傝繖閲屾垜浠畾涔変竴涓嚱鏁帮紝琛ㄧず鐘舵併俶(1,2,3,4..i)(w)琛ㄧず鏈1鍙,2...
绛旓細鏈変簡杩欎釜杩囩▼浠ュ悗锛01鑳屽寘闂鐨浼唬鐮佸氨鍙互杩欐牱鍐欙細for i=1..N ZeroOnePack(c,w);鍒濆鍖栫殑缁嗚妭闂 鎴戜滑鐪嬪埌鐨勬眰鏈浼樿В鐨勮儗鍖呴棶棰橀鐩腑锛屼簨瀹炰笂鏈変袱绉嶄笉澶浉鍚岀殑闂硶銆傛湁鐨勯鐩姹傗滄伆濂借婊¤儗鍖呪濇椂鐨勬渶浼樿В锛屾湁鐨勯鐩垯骞舵病鏈夎姹傚繀椤绘妸鑳屽寘瑁呮弧銆備竴绉嶅尯鍒繖涓ょ闂硶鐨勫疄鐜版柟娉曟槸鍦ㄥ垵濮嬪寲...
绛旓細cout<<"鑳屽寘鐨勬婚噸閲忎负:"<<totalw<<endl; //鑳屽寘鎵瑁呰浇鎬婚噸閲 cout<<"鑳屽寘鐨勬讳环鍊间负:"<<totalv<<endl; //鑳屽寘鐨勬讳环鍊 } 涓.鍥炴函绠楁硶姹傝В0-1鑳屽寘闂 1.0-l鑳屽寘闂鏄瓙闆嗛夊彇闂銆 涓鑸儏鍐典笅,0-1鑳屽寘闂鏄疦P闅鹃銆0-1鑳屽寘 闂鐨瑙ｇ┖闂村彲鐢ㄥ瓙闆嗘爲琛ㄧず銆傝В0-1鑳屽寘闂鐨鍥炴函娉曚笌瑁呰浇闂鐨...
绛旓細1.瀹炴暟鑳屽寘 鐗╁搧鍙互涓閮ㄥ垎鏀惧湪鑳屽寘涓紝閭ｄ箞鐩存帴璐績灏辫浜嗭紝鎶婄墿鍝佹寜鎬т环姣(v[i]/w[i])鍗囧簭鏀惧叆鍗充负鏈浼樿В銆傚鏉傚害O(n+nlogn)2.鏁存暟鑳屽寘 鐗╁搧鍙兘鏁翠釜鏀惧叆鑳屽寘锛屼笉鍏佽鎷嗗紑鏀撅紝鐢ㄥ姩鎬佽鍒姹傝В銆俤p[i,j]琛ㄧず鍓峣涓墿鍝佹斁鍏ュ閲忎负j鐨勮儗鍖呬腑鍙互寰楀埌鐨勬渶浼樿В銆傜姸鎬佽浆绉绘柟绋嬶細dp[i,j]=max{dp[...
绛旓細鑰冭檻涓涓粡鍏哥殑鑳屽寘闂锛屾湁N绉嶇墿鍝侊紝姣忕鐗╁搧鏈澶氭湁n浠讹紝浣撶Н涓篶锛屼环鍊间负w锛岃儗鍖呭閲忎负V銆傜洰鏍囨槸鎵惧埌涓绉嶇粍鍚堬紝浣跨墿鍝佷綋绉笉瓒呰繃鑳屽寘瀹归噺锛屽悓鏃朵环鍊兼渶澶с傚熀鏈殑瑙ｅ喅绛栫暐绫讳技浜庡畬鍏ㄨ儗鍖呴棶棰橈紝閫氳繃鍔ㄦ佽鍒姹傝В銆傚畾涔塮[v]涓哄墠i绉嶇墿鍝佹斁鍏ュ閲忎负v鐨勮儗鍖呯殑鏈澶т环鍊硷紝鍏剁姸鎬佽浆绉绘柟绋嬩负锛歠[v] = max{...
绛旓細濡傛灉鑲畾涓嶅寘鍚紝鍒欒烦杩囧浠ヨ缁撶偣涓烘牴鐨勫瓙鏍戠殑绯荤粺鎼滅储锛岄愬眰鍚戝叾鍘熷厛缁撶偣鍥炴函銆傚惁鍒欙紝杩涘叆璇ュ瓙鏍戯紝缁х画鎸夋繁搴︿紭鍏堢殑绛栫暐杩涜鎼滅储銆傝鍫備笂鑰佸笀宸茬粡璁茶В杩囩敤鍥炴函娉曡В鍐硁-鐨囧悗闂锛宮-鍥剧潃鑹查棶棰樹互鍙婂搱瀵嗛】鐜棶棰橈紝浠栦滑鏈夌浉鍚岀殑鐗瑰緛鍗闂鐨勬眰瑙鐩爣閮芥槸姹傛弧瓒崇害鏉熸潯浠剁殑鍏ㄩ儴鍙瑙ｃ傝0/1鑳屽寘鏄渶浼樺寲闂...
