軟件水平考試常用算法設(shè)計方法

    要使計算機(jī)能完成人們預(yù)定的工作，首先必須為如何完成預(yù)定的工作設(shè)計一個算法，然后再根據(jù)算法編寫程序。計算機(jī)程序要對問題的每個對象和處理規(guī)則給出正確詳盡的描述，其中程序的數(shù)據(jù)結(jié)構(gòu)和變量用來描述問題的對象，程序結(jié)構(gòu)、函數(shù)和語句用來描述問題的算法。算法數(shù)據(jù)結(jié)構(gòu)是程序的兩個重要方面。

　　算法是問題求解過程的精確描述，一個算法由有限條可完全機(jī)械地執(zhí)行的、有確定結(jié)果的指令組成。指令正確地描述了要完成的任務(wù)和它們被執(zhí)行的順序。計算機(jī)按算法指令所描述的順序執(zhí)行算法的指令能在有限的步驟內(nèi)終止，或終止于給出問題的解，或終止于指出問題對此輸入數(shù)據(jù)無解。

　　通常求解一個問題可能會有多種算法可供選擇，選擇的主要標(biāo)準(zhǔn)是算法的正確性和可靠性，簡單性和易理解性。其次是算法所需要的存儲空間少和執(zhí)行更快等。

　　算法設(shè)計是一件非常困難的工作，經(jīng)常采用的算法設(shè)計技術(shù)主要有迭代法、窮舉搜索法、遞推法、貪婪法、回溯法、分治法、動態(tài)規(guī)劃法等等。另外，為了更簡潔的形式設(shè)計和藐視算法，在算法設(shè)計時又常常采用遞歸技術(shù)，用遞歸描述算法。
　　
    一、迭代法

　　迭代法是用于求方程或方程組近似根的一種常用的算法設(shè)計方法。設(shè)方程為f(x)=0，用某種數(shù)學(xué)方法導(dǎo)出等價的形式x=g(x)，然后按以下步驟執(zhí)行：
　�。�1） 選一個方程的近似根，賦給變量x0；
　　（2） 將x0的值保存于變量x1，然后計算g(x1)，并將結(jié)果存于變量x0；
　�。�3） 當(dāng)x0與x1的差的絕對值還小于指定的精度要求時，重復(fù)步驟（2）的計算。
　　若方程有根，并且用上述方法計算出來的近似根序列收斂，則按上述方法求得的x0就認(rèn)為是方程的根。上述算法用C程序的形式表示為：
　　【算法】迭代法求方程的根
　　{ x0=初始近似根；
　　 do {
　　 x1=x0；
　　 x0=g(x1)； /*按特定的方程計算新的近似根*/
　　 } while ( fabs(x0-x1)>Epsilon)；
　　 printf(“方程的近似根是%f\n”，x0)；
　　}
　　迭代算法也常用于求方程組的根，令
　　 X=（x0，x1，…，xn-1）
　　設(shè)方程組為：
　　 xi=gi(X) (I=0，1，…，n-1)
　　則求方程組根的迭代算法可描述如下：
　　【算法】迭代法求方程組的根
　　 { for (i=0;i　　 x[i]=初始近似根;
　　 do {
　　 for (i=0;i　　 y[i]=x[i];
　　 for (i=0;i　　 x[i]=gi(X);
　　 for (delta=0.0,i=0;i　　 if (fabs(y[i]-x[i])>delta) delta=fabs(y[i]-x[i])；
　　 } while (delta>Epsilon)；
　　 for (i=0;i　　 printf(“變量x[%d]的近似根是 %f”，I，x[i])；
　　 printf(“\n”)；
　　 }
　　 具體使用迭代法求根時應(yīng)注意以下兩種可能發(fā)生的情況：
　�。�1） 如果方程無解，算法求出的近似根序列就不會收斂，迭代過程會變成死循環(huán)，因此在使用迭代算法前應(yīng)先考察方程是否有解，并在程序中對迭代的次數(shù)給予限制；
　　（2） 方程雖然有解，但迭代公式選擇不當(dāng)，或迭代的初始近似根選擇不合理，也會導(dǎo)致迭代失敗。

　　二、窮舉搜索法

　　 窮舉搜索法是對可能是解的眾多候選解按某種順序進(jìn)行逐一枚舉和檢驗，并從眾找出那些符合要求的候選解作為問題的解。
　　【問題】 將A、B、C、D、E、F這六個變量排成如圖所示的三角形，這六個變量分別取[1，6]上的整數(shù)，且均不相同。求使三角形三條邊上的變量之和相等的全部解。如圖就是一個解。
　　程序引入變量a、b、c、d、e、f，并讓它們分別順序取1至6的證書，在它們互不相同的條件下，測試由它們排成的如圖所示的三角形三條邊上的變量之和是否相等，如相等即為一種滿足要求的排列，把它們輸出。當(dāng)這些變量取盡所有的組合后，程序就可得到全部可能的解。細(xì)節(jié)見下面的程序。
　　【程序1】
　　# include
　　void main()
　　{ int a,b,c,d,e,f;
　　 for (a=1;a<=6;a++)
　　 for (b=1;b<=6;b++) {
　　 if (b==a) continue;
　　 for (c=1;c<=6;c++) {
　　 if (c==a)||(c==b) continue;
　　 for (d=1;d<=6;d++) {
　　 if (d==a)||(d==b)||(d==c) continue;
　　for (e=1;e<=6;e++) {
　　 if (e==a)||(e==b)||(e==c)||(e==d) continue;
　　f=21-(a+b+c+d+e);
　　if ((a+b+c==c+d+e))&&(a+b+c==e+f+a)) {
　　printf(“%6d,a);
　　 printf(“%4d%4d”,b,f);
　　 printf(“%2d%4d%4d”,c,d,e);
　　 scanf(“%*c”);
　　}
　　 }
　　 }
　　 }
　　 }
　　 }
　　按窮舉法編寫的程序通常不能適應(yīng)變化的情況。如問題改成有9個變量排成三角形，每條邊有4個變量的情況，程序的循環(huán)重數(shù)就要相應(yīng)改變。
　　 對一組數(shù)窮盡所有排列，還有更直接的方法。將一個排列看作一個長整數(shù)，則所有排列對應(yīng)著一組整數(shù)。將這組整數(shù)按從小到大的順序排列排成一個整數(shù)，從對應(yīng)最小的整數(shù)開始。按數(shù)列的遞增順序逐一列舉每個排列對應(yīng)的每個整數(shù)，這能更有效地完成排列的窮舉。從一個排列找出對應(yīng)數(shù)列的下一個排列可在當(dāng)前排列的基礎(chǔ)上作部分調(diào)整來實現(xiàn)。倘若當(dāng)前排列為1，2，4，6，5，3，并令其對應(yīng)的長整數(shù)為124653。要尋找比長整數(shù)124653更大的排列，可從該排列的最后一個數(shù)字順序向前逐位考察，當(dāng)發(fā)現(xiàn)排列中的某個數(shù)字比它前一個數(shù)字大時，如本例中的6比它的前一位數(shù)字4大，這說明還有對應(yīng)更大整數(shù)的排列。但為了順序從小到大列舉出所有的排列，不能立即調(diào)整得太大，如本例中將數(shù)字6與數(shù)字4交換得到的排列126453就不是排列124653的下一個排列。為了得到排列124653的下一個排列，應(yīng)從已經(jīng)考察過的那部分?jǐn)?shù)字中選出比數(shù)字大，但又是它們中最小的那一個數(shù)字，比如數(shù)字5，與數(shù)字4交換。該數(shù)字也是從后向前考察過程中第一個比4大的數(shù)字。5與4交換后，得到排列125643。在前面數(shù)字1，2，5固定的情況下，還應(yīng)選擇對應(yīng)最小整數(shù)的那個排列，為此還需將后面那部分?jǐn)?shù)字的排列順序顛倒，如將數(shù)字6，4，3的排列順序顛倒，得到排列1，2，5，3，4，6，這才是排列1，2，4，6，5，3的下一個排列。按以上想法編寫的程序如下。
　　【程序2】
　　# include
　　# define SIDE_N 3
　　# define LENGTH 3
　　# define VARIABLES 6
　　int A,B,C,D,E,F;
　　int *pt[]={&A,&B,&C,&D,&E,&F};
　　int *side[SIDE_N][LENGTH]={&A,&B,&C,&C,&D,&E,&E,&F,&A};
　　int side_total[SIDE_N];
　　main{}
　　{ int i,j,t,equal;
　　 for (j=0;j　　 *pt[j]=j+1;
　　 while(1)
　　 { for (i=0;i　　 { for (t=j=0;j　　 t+=*side[i][j];
　　 side_total[i]=t;
　　 }
　　 for (equal=1,i=0;equal&&i　　 if (side_total[i]!=side_total[i+1] equal=0;
　　 if (equal)
　　 { for (i=1;i　　 printf(“%4d”,*pt[i]);
　　 printf(“\n”);
　　 scanf(“%*c”);
　　 }
　　 for (j=VARIABLES-1;j>0;j--)
　　 if (*pt[j]>*pt[j-1]) break;
　　 if (j==0) break;
　　 for (i=VARIABLES-1;i>=j;i--)
　　 if (*pt[i]>*pt[i-1]) break;
　　 t=*pt[j-1];* pt[j-1] =* pt[i]; *pt[i]=t;
　　 for (i=VARIABLES-1;i>j;i--,j++)
　　 { t=*pt[j]; *pt[j] =* pt[i]; *pt[i]=t; }
　　 }
　　}
　　從上述問題解決的方法中，最重要的因素就是確定某種方法來確定所有的候選解。下面再用一個示例來加以說明。
　　【問題】 背包問題
　　問題描述：有不同價值、不同重量的物品n件，求從這n件物品中選取一部分物品的選擇方案，使選中物品的總重量不超過指定的限制重量，但選中物品的價值之和最大。
　　設(shè)n個物品的重量和價值分別存儲于數(shù)組w[ ]和v[ ]中，限制重量為tw�？紤]一個n元組（x0，x1，…，xn-1），其中xi=0 表示第i個物品沒有選取，而xi=1則表示第i個物品被選取。顯然這個n元組等價于一個選擇方案。用枚舉法解決背包問題，需要枚舉所有的選取方案，而根據(jù)上述方法，我們只要枚舉所有的n元組，就可以得到問題的解。
　　顯然，每個分量取值為0或1的n元組的個數(shù)共為2n個。而每個n元組其實對應(yīng)了一個長度為n的二進(jìn)制數(shù)，且這些二進(jìn)制數(shù)的取值范圍為0～2n-1。因此，如果把0～2n-1分別轉(zhuǎn)化為相應(yīng)的二進(jìn)制數(shù)，則可以得到我們所需要的2n個n元組。
　　【算法】
　　maxv=0;
　　for (i=0;i<2n;i++)
　　{ B[0..n-1]=0;
　　 把i轉(zhuǎn)化為二進(jìn)制數(shù)，存儲于數(shù)組B中;
　　 temp_w=0;
　　 temp_v=0;
　　 for (j=0;j　　 { if (B[j]==1)
　　 { temp_w=temp_w+w[j];
　　 temp_v=temp_v+v[j];
　　 }
　　 if ((temp_w<=tw)&&(temp_v>maxv))
　　 { maxv=temp_v;
　　 保存該B數(shù)組；
　　 }
　　 }
　　}
　　
　　三、遞推法

　　 遞推法是利用問題本身所具有的一種遞推關(guān)系求問題解的一種方法。設(shè)要求問題規(guī)模為N的解，當(dāng)N=1時，解或為已知，或能非常方便地得到解。能采用遞推法構(gòu)造算法的問題有重要的遞推性質(zhì)，即當(dāng)?shù)玫絾栴}規(guī)模為i-1的解后，由問題的遞推性質(zhì)，能從已求得的規(guī)模為1，2，…，i-1的一系列解，構(gòu)造出問題規(guī)模為I的解。這樣，程序可從i=0或i=1出發(fā)，重復(fù)地，由已知至i-1規(guī)模的解，通過遞推，獲得規(guī)模為i的解，直至得到規(guī)模為N的解。
　　【問題】 階乘計算
　　問題描述：編寫程序，對給定的n（n≦100），計算并輸出k的階乘k�。╧=1，2，…，n）的全部有效數(shù)字。
　　由于要求的整數(shù)可能大大超出一般整數(shù)的位數(shù)，程序用一維數(shù)組存儲長整數(shù)，存儲長整數(shù)數(shù)組的每個元素只存儲長整數(shù)的一位數(shù)字。如有m位成整數(shù)N用數(shù)組a[ ]存儲：
　　 N=a[m]×10m-1+a[m-1]×10m-2+ … +a[2]×101+a[1]×100
　　并用a[0]存儲長整數(shù)N的位數(shù)m，即a[0]=m。按上述約定，數(shù)組的每個元素存儲k的階乘k！的一位數(shù)字，并從低位到高位依次存于數(shù)組的第二個元素、第三個元素……。例如，5！=120，在數(shù)組中的存儲形式為：
　　3 0 2 1 ……
　　首元素3表示長整數(shù)是一個3位數(shù)，接著是低位到高位依次是0、2、1，表示成整數(shù)120。
　　 計算階乘k！可采用對已求得的階乘(k-1)！連續(xù)累加k-1次后求得。例如，已知4！=24，計算5！，可對原來的24累加4次24后得到120。細(xì)節(jié)見以下程序。
　　# include
　　# include
　　# define MAXN 1000
　　void pnext(int a[ ],int k)
　　{ int *b,m=a[0],i,j,r,carry;
　　 b=(int * ) malloc(sizeof(int)* (m+1));
　　 for ( i=1;i<=m;i++) b[i]=a[i];
　　 for ( j=1;j<=k;j++)
　　 { for ( carry=0,i=1;i<=m;i++)
　　 { r=(i　　 a[i]=r%10;
　　 carry=r/10;
　　 }
　　 if (carry) a[++m]=carry;
　　 }
　　 free(b);
　　 a[0]=m;
　　}
　　
　　void write(int *a,int k)
　　{ int i;
　　 printf(“%4d！=”,k);
　　 for (i=a[0];i>0;i--)
　　 printf(“%d”,a[i]);
　　printf(“\n\n”);
　　}
　　
　　void main()
　　{ int a[MAXN],n,k;
　　 printf(“Enter the number n: “);
　　 scanf(“%d”,&n);
　　 a[0]=1;
　　 a[1]=1;
　　 write(a,1);
　　 for (k=2;k<=n;k++)
　　 { pnext(a,k);
　　 write(a,k);
　　 getchar();
　　 }
　　}

　　四、遞歸

　　 遞歸是設(shè)計和描述算法的一種有力的工具，由于它在復(fù)雜算法的描述中被經(jīng)常采用，為此在進(jìn)一步介紹其他算法設(shè)計方法之前先討論它。
　　 能采用遞歸描述的算法通常有這樣的特征：為求解規(guī)模為N的問題，設(shè)法將它分解成規(guī)模較小的問題，然后從這些小問題的解方便地構(gòu)造出大問題的解，并且這些規(guī)模較小的問題也能采用同樣的分解和綜合方法，分解成規(guī)模更小的問題，并從這些更小問題的解構(gòu)造出規(guī)模較大問題的解。特別地，當(dāng)規(guī)模N=1時，能直接得解。
　　【問題】 編寫計算斐波那契（Fibonacci）數(shù)列的第n項函數(shù)fib（n）。
　　 斐波那契數(shù)列為：0、1、1、2、3、……，即：
　　 fib(0)=0;
　　 fib(1)=1;
　　 fib(n)=fib(n-1)+fib(n-2) （當(dāng)n>1時）。
　　寫成遞歸函數(shù)有：
　　int fib(int n)
　　{ if (n==0) return 0;
　　 if (n==1) return 1;
　　 if (n>1) return fib(n-1)+fib(n-2);
　　}
　　 遞歸算法的執(zhí)行過程分遞推和回歸兩個階段。在遞推階段，把較復(fù)雜的問題（規(guī)模為n）的求解推到比原問題簡單一些的問題（規(guī)模小于n）的求解。例如上例中，求解fib(n)，把它推到求解fib(n-1)和fib(n-2)。也就是說，為計算fib(n)，必須先計算fib(n-1)和fib(n-2)，而計算fib(n-1)和fib(n-2)，又必須先計算fib(n-3)和fib(n-4)。依次類推，直至計算fib(1)和fib(0)，分別能立即得到結(jié)果1和0。在遞推階段，必須要有終止遞歸的情況。例如在函數(shù)fib中，當(dāng)n為1和0的情況。
　　 在回歸階段，當(dāng)獲得最簡單情況的解后，逐級返回，依次得到稍復(fù)雜問題的解，例如得到fib(1)和fib(0)后，返回得到fib(2)的結(jié)果，……，在得到了fib(n-1)和fib(n-2)的結(jié)果后，返回得到fib(n)的結(jié)果。
　　 在編寫遞歸函數(shù)時要注意，函數(shù)中的局部變量和參數(shù)知識局限于當(dāng)前調(diào)用層，當(dāng)遞推進(jìn)入“簡單問題”層時，原來層次上的參數(shù)和局部變量便被隱蔽起來。在一系列“簡單問題”層，它們各有自己的參數(shù)和局部變量。
　　 由于遞歸引起一系列的函數(shù)調(diào)用，并且可能會有一系列的重復(fù)計算，遞歸算法的執(zhí)行效率相對較低。當(dāng)某個遞歸算法能較方便地轉(zhuǎn)換成遞推算法時，通常按遞推算法編寫程序。例如上例計算斐波那契數(shù)列的第n項的函數(shù)fib(n)應(yīng)采用遞推算法，即從斐波那契數(shù)列的前兩項出發(fā)，逐次由前兩項計算出下一項，直至計算出要求的第n項。
　　【問題】 組合問題
　　問題描述：找出從自然數(shù)1、2、……、n中任取r個數(shù)的所有組合。例如n=5，r=3的所有組合為： （1）5、4、3 （2）5、4、2 （3）5、4、1
　　 （4）5、3、2 （5）5、3、1 （6）5、2、1
　　 （7）4、3、2 （8）4、3、1 （9）4、2、1
　　 （10）3、2、1
　　 分析所列的10個組合，可以采用這樣的遞歸思想來考慮求組合函數(shù)的算法。設(shè)函數(shù)為void comb(int m,int k)為找出從自然數(shù)1、2、……、m中任取k個數(shù)的所有組合。當(dāng)組合的第一個數(shù)字選定時，其后的數(shù)字是從余下的m-1個數(shù)中取k-1數(shù)的組合。這就將求m個數(shù)中取k個數(shù)的組合問題轉(zhuǎn)化成求m-1個數(shù)中取k-1個數(shù)的組合問題。設(shè)函數(shù)引入工作數(shù)組a[ ]存放求出的組合的數(shù)字，約定函數(shù)將確定的k個數(shù)字組合的第一個數(shù)字放在a[k]中，當(dāng)一個組合求出后，才將a[ ]中的一個組合輸出。第一個數(shù)可以是m、m-1、……、k，函數(shù)將確定組合的第一個數(shù)字放入數(shù)組后，有兩種可能的選擇，因還未去頂組合的其余元素，繼續(xù)遞歸去確定；或因已確定了組合的全部元素，輸出這個組合。細(xì)節(jié)見以下程序中的函數(shù)comb。
　　【程序】
　　# include
　　# define MAXN 100
　　int a[MAXN];
　　void comb(int m,int k)
　　{ int i,j;
　　 for (i=m;i>=k;i--)
　　 { a[k]=i;
　　 if (k>1)
　　 comb(i-1,k-1);
　　 else
　　 { for (j=a[0];j>0;j--)
　　 printf(“%4d”,a[j]);
　　 printf(“\n”);
　　 }
　　 }
　　}
　　
　　void main()
　　{ a[0]=3;
　　 comb(5,3);
　　}
　　【問題】 背包問題
　　問題描述：有不同價值、不同重量的物品n件，求從這n件物品中選取一部分物品的選擇方案，使選中物品的總重量不超過指定的限制重量，但選中物品的價值之和最大。
　　設(shè)n件物品的重量分別為w0、w1、…、wn-1，物品的價值分別為v0、v1、…、vn-1。采用遞歸尋找物品的選擇方案。設(shè)前面已有了多種選擇的方案，并保留了其中總價值最大的方案于數(shù)組option[ ]，該方案的總價值存于變量maxv。當(dāng)前正在考察新方案，其物品選擇情況保存于數(shù)組cop[ ]。假定當(dāng)前方案已考慮了前i-1件物品，現(xiàn)在要考慮第i件物品；當(dāng)前方案已包含的物品的重量之和為tw；至此，若其余物品都選擇是可能的話，本方案能達(dá)到的總價值的期望值為tv。算法引入tv是當(dāng)一旦當(dāng)前方案的總價值的期望值也小于前面方案的總價值maxv時，繼續(xù)考察當(dāng)前方案變成無意義的工作，應(yīng)終止當(dāng)前方案，立即去考察下一個方案。因為當(dāng)方案的總價值不比maxv大時，該方案不會被再考察，這同時保證函數(shù)后找到的方案一定會比前面的方案更好。
　　對于第i件物品的選擇考慮有兩種可能：
　�。�1） 考慮物品i被選擇，這種可能性僅當(dāng)包含它不會超過方案總重量限制時才是可行的。選中后，繼續(xù)遞歸去考慮其余物品的選擇。
　　（2） 考慮物品i不被選擇，這種可能性僅當(dāng)不包含物品i也有可能會找到價值更大的方案的情況。
　　按以上思想寫出遞歸算法如下：
　　try(物品i，當(dāng)前選擇已達(dá)到的重量和，本方案可能達(dá)到的總價值tv)
　　{ /*考慮物品i包含在當(dāng)前方案中的可能性*/
　　 if(包含物品i是可以接受的)
　　 { 將物品i包含在當(dāng)前方案中；
　　 if (i　　 try(i+1,tw+物品i的重量,tv);
　　 else
　　 /*又一個完整方案，因為它比前面的方案好，以它作為最佳方案*/
　　以當(dāng)前方案作為臨時最佳方案保存;
　　 恢復(fù)物品i不包含狀態(tài)；
　　 }
　　 /*考慮物品i不包含在當(dāng)前方案中的可能性*/
　　 if (不包含物品i僅是可男考慮的)
　　 if (i　　 try(i+1,tw,tv-物品i的價值)；
　　 else
　　 /*又一個完整方案，因它比前面的方案好，以它作為最佳方案*/
　　以當(dāng)前方案作為臨時最佳方案保存;
　　 }
　　 為了理解上述算法，特舉以下實例。設(shè)有4件物品，它們的重量和價值見表：
　　物品 0 1 2 3
　　重量 5 3 2 1
　　價值 4 4 3 1
　　
　　并設(shè)限制重量為7。則按以上算法，下圖表示找解過程。由圖知，一旦找到一個解，算法就進(jìn)一步找更好的佳。如能判定某個查找分支不會找到更好的解，算法不會在該分支繼續(xù)查找，而是立即終止該分支，并去考察下一個分支。
　　
　　按上述算法編寫函數(shù)和程序如下：
　　【程序】
　　# include
　　# define N 100
　　double limitW,totV,maxV;
　　int option[N],cop[N];
　　struct { double weight;
　　 double value;
　　 }a[N];
　　int n;
　　void find(int i,double tw,double tv)
　　{ int k;
　　 /*考慮物品i包含在當(dāng)前方案中的可能性*/
　　 if (tw+a[i].weight<=limitW)
　　 { cop[i]=1;
　　 if (i　　 else
　　 { for (k=0;k　　 option[k]=cop[k];
　　 maxv=tv;
　　 }
　　 cop[i]=0;
　　}
　　 /*考慮物品i不包含在當(dāng)前方案中的可能性*/
　　 if (tv-a[i].value>maxV)
　　 if (i　　 else
　　 { for (k=0;k　　 option[k]=cop[k];
　　 maxv=tv-a[i].value;
　　 }
　　}
　　
　　void main()
　　{ int k;
　　 double w,v;
　　 printf(“輸入物品種數(shù)\n”);
　　 scanf((“%d”,&n);
　　 printf(“輸入各物品的重量和價值\n”);
　　 for (totv=0.0,k=0;k　　 { scanf(“%1f%1f”,&w,&v);
　　 a[k].weight=w;
　　 a[k].value=v;
　　 totV+=V;
　　 }
　　 printf(“輸入限制重量\n”);
　　 scanf(“%1f”,&limitV);
　　 maxv=0.0;
　　 for (k=0;k　　 find(0,0.0,totV);
　　 for (k=0;k　　 if (option[k]) printf(“%4d”,k+1);
　　 printf(“\n總價值為%.2f\n”,maxv);
　　}
　　 作為對比，下面以同樣的解題思想，考慮非遞歸的程序解。為了提高找解速度，程序不是簡單地逐一生成所有候選解，而是從每個物品對候選解的影響來形成值得進(jìn)一步考慮的候選解，一個候選解是通過依次考察每個物品形成的。對物品i的考察有這樣幾種情況：當(dāng)該物品被包含在候選解中依舊滿足解的總重量的限制，該物品被包含在候選解中是應(yīng)該繼續(xù)考慮的；反之，該物品不應(yīng)該包括在當(dāng)前正在形成的候選解中。同樣地，僅當(dāng)物品不被包括在候選解中，還是有可能找到比目前臨時最佳解更好的候選解時，才去考慮該物品不被包括在候選解中；反之，該物品不包括在當(dāng)前候選解中的方案也不應(yīng)繼續(xù)考慮。對于任一值得繼續(xù)考慮的方案，程序就去進(jìn)一步考慮下一個物品。
　　【程序】
　　# include
　　# define N 100
　　double limitW;
　　int cop[N];
　　struct ele { double weight;
　　 double value;
　　 } a[N];
　　int k,n;
　　struct { int flg;
　　 double tw;
　　 double tv;
　　 }twv[N];
　　void next(int i,double tw,double tv)
　　{ twv[i].flg=1;
　　 twv[i].tw=tw;
　　 twv[i].tv=tv;
　　}
　　double find(struct ele *a,int n)
　　{ int i,k,f;
　　 double maxv,tw,tv,totv;
　　 maxv=0;
　　 for (totv=0.0,k=0;k　　 totv+=a[k].value;
　　 next(0,0.0,totv);
　　 i=0;
　　 While (i>=0)
　　 { f=twv[i].flg;
　　 tw=twv[i].tw;
　　 tv=twv[i].tv;
　　 switch(f)
　　 { case 1: twv[i].flg++;
　　 if (tw+a[i].weight<=limitW)
　　 if (i　　 { next(i+1,tw+a[i].weight,tv);
　　 i++;
　　 }
　　 else
　　 { maxv=tv;
　　 for (k=0;k　　 cop[k]=twv[k].flg!=0;
　　 }
　　 break;
　　 case 0: i--;
　　 break;
　　 default: twv[i].flg=0;
　　 if (tv-a[i].value>maxv)
　　 if (i　　 { next(i+1,tw,tv-a[i].value);
　　 i++;
　　 }
　　 else
　　 { maxv=tv-a[i].value;
　　 for (k=0;k　　 cop[k]=twv[k].flg!=0;
　　 }
　　 break;
　　 }
　　 }
　　 return maxv;
　　}
　　
　　void main()
　　{ double maxv;
　　 printf(“輸入物品種數(shù)\n”);
　　 scanf((“%d”,&n);
　　 printf(“輸入限制重量\n”);
　　 scanf(“%1f”,&limitW);
　　printf(“輸入各物品的重量和價值\n”);
　　 for (k=0;k　　 scanf(“%1f%1f”,&a[k].weight,&a[k].value);
　　 maxv=find(a,n);
　　 printf(“\n選中的物品為\n”);
　　for (k=0;k　　 if (option[k]) printf(“%4d”,k+1);
　　 printf(“\n總價值為%.2f\n”,maxv);
　　}

　　五、回溯法

　　 回溯法也稱為試探法，該方法首先暫時放棄關(guān)于問題規(guī)模大小的限制，并將問題的候選解按某種順序逐一枚舉和檢驗。當(dāng)發(fā)現(xiàn)當(dāng)前候選解不可能是解時，就選擇下一個候選解；倘若當(dāng)前候選解除了還不滿足問題規(guī)模要求外，滿足所有其他要求時，繼續(xù)擴(kuò)大當(dāng)前候選解的規(guī)模，并繼續(xù)試探。如果當(dāng)前候選解滿足包括問題規(guī)模在內(nèi)的所有要求時，該候選解就是問題的一個解。在回溯法中，放棄當(dāng)前候選解，尋找下一個候選解的過程稱為回溯。擴(kuò)大當(dāng)前候選解的規(guī)模，以繼續(xù)試探的過程稱為向前試探。

　　1、回溯法的一般描述

　　可用回溯法求解的問題P，通常要能表達(dá)為：對于已知的由n元組（x1，x2，…，xn）組成的一個狀態(tài)空間E={（x1，x2，…，xn）∣xi∈Si ，i=1，2，…，n}，給定關(guān)于n元組中的一個分量的一個約束集D，要求E中滿足D的全部約束條件的所有n元組。其中Si是分量xi的定義域，且 |Si| 有限，i=1，2，…，n。我們稱E中滿足D的全部約束條件的任一n元組為問題P的一個解。

　　解問題P的最樸素的方法就是枚舉法，即對E中的所有n元組逐一地檢測其是否滿足D的全部約束，若滿足，則為問題P的一個解。但顯然，其計算量是相當(dāng)大的。

　　我們發(fā)現(xiàn)，對于許多問題，所給定的約束集D具有完備性，即i元組（x1，x2，…，xi）滿足D中僅涉及到x1，x2，…，xi的所有約束意味著j（jj。因此，對于約束集D具有完備性的問題P，一旦檢測斷定某個j元組（x1，x2，…，xj）違反D中僅涉及x1，x2，…，xj的一個約束，就可以肯定，以（x1，x2，…，xj）為前綴的任何n元組（x1，x2，…，xj，xj+1，…，xn）都不會是問題P的解，因而就不必去搜索它們、檢測它們。回溯法正是針對這類問題，利用這類問題的上述性質(zhì)而提出來的比枚舉法效率更高的算法。

　　回溯法首先將問題P的n元組的狀態(tài)空間E表示成一棵高為n的帶權(quán)有序樹T，把在E中求問題P的所有解轉(zhuǎn)化為在T中搜索問題P的所有解。樹T類似于檢索樹，它可以這樣構(gòu)造：

　　設(shè)Si中的元素可排成xi(1) ，xi(2) ，…，xi(mi-1) ，|Si| =mi，i=1，2，…，n。從根開始，讓T的第I層的每一個結(jié)點都有mi個兒子。這mi個兒子到它們的雙親的邊，按從左到右的次序，分別帶權(quán)xi+1(1) ，xi+1(2) ，…，xi+1(mi) ，i=0，1，2，…，n-1。照這種構(gòu)造方式，E中的一個n元組（x1，x2，…，xn）對應(yīng)于T中的一個葉子結(jié)點，T的根到這個葉子結(jié)點的路徑上依次的n條邊的權(quán)分別為x1，x2，…，xn，反之亦然。另外，對于任意的0≤i≤n-1，E中n元組（x1，x2，…，xn）的一個前綴I元組（x1，x2，…，xi）對應(yīng)于T中的一個非葉子結(jié)點，T的根到這個非葉子結(jié)點的路徑上依次的I條邊的權(quán)分別為x1，x2，…，xi，反之亦然。特別，E中的任意一個n元組的空前綴（），對應(yīng)于T的根。

　　 因而，在E中尋找問題P的一個解等價于在T中搜索一個葉子結(jié)點，要求從T的根到該葉子結(jié)點的路徑上依次的n條邊相應(yīng)帶的n個權(quán)x1，x2，…，xn滿足約束集D的全部約束。在T中搜索所要求的葉子結(jié)點，很自然的一種方式是從根出發(fā)，按深度優(yōu)先的策略逐步深入，即依次搜索滿足約束條件的前綴1元組（x1i）、前綴2元組（x1，x2）、…，前綴I元組（x1，x2，…，xi），…，直到i=n為止。

　　 在回溯法中，上述引入的樹被稱為問題P的狀態(tài)空間樹；樹T上任意一個結(jié)點被稱為問題P的狀態(tài)結(jié)點；樹T上的任意一個葉子結(jié)點被稱為問題P的一個解狀態(tài)結(jié)點；樹T上滿足約束集D的全部約束的任意一個葉子結(jié)點被稱為問題P的一個回答狀態(tài)結(jié)點，它對應(yīng)于問題P的一個解。

　　【問題】 組合問題
　　問題描述：找出從自然數(shù)1、2、……、n中任取r個數(shù)的所有組合。
　　例如n=5，r=3的所有組合為：
　�。�1）1、2、3 （2）1、2、4 （3）1、2、5
　　 （4）1、3、4 （5）1、3、5 （6）1、4、5
　　 （7）2、3、4 （8）2、3、5 （9）2、4、5
　　 （10）3、4、5
　　則該問題的狀態(tài)空間為：
　　E={（x1，x2，x3）∣xi∈S ，i=1，2，3 } 其中：S={1，2，3，4，5}
　　約束集為： x1　　 顯然該約束集具有完備性。
　　問題的狀態(tài)空間樹T：
　
　　2、回溯法的方法

　　 對于具有完備約束集D的一般問題P及其相應(yīng)的狀態(tài)空間樹T，利用T的層次結(jié)構(gòu)和D的完備性，在T中搜索問題P的所有解的回溯法可以形象地描述為：

　　 從T的根出發(fā)，按深度優(yōu)先的策略，系統(tǒng)地搜索以其為根的子樹中可能包含著回答結(jié)點的所有狀態(tài)結(jié)點，而跳過對肯定不含回答結(jié)點的所有子樹的搜索，以提高搜索效率。具體地說，當(dāng)搜索按深度優(yōu)先策略到達(dá)一個滿足D中所有有關(guān)約束的狀態(tài)結(jié)點時，即“激活”該狀態(tài)結(jié)點，以便繼續(xù)往深層搜索；否則跳過對以該狀態(tài)結(jié)點為根的子樹的搜索，而一邊逐層地向該狀態(tài)結(jié)點的祖先結(jié)點回溯，一邊“殺死”其兒子結(jié)點已被搜索遍的祖先結(jié)點，直到遇到其兒子結(jié)點未被搜索遍的祖先結(jié)點，即轉(zhuǎn)向其未被搜索的一個兒子結(jié)點繼續(xù)搜索。

　　在搜索過程中，只要所激活的狀態(tài)結(jié)點又滿足終結(jié)條件，那么它就是回答結(jié)點，應(yīng)該把它輸出或保存。由于在回溯法求解問題時，一般要求出問題的所有解，因此在得到回答結(jié)點后，同時也要進(jìn)行回溯，以便得到問題的其他解，直至回溯到T的根且根的所有兒子結(jié)點均已被搜索過為止。

　　 例如在組合問題中，從T的根出發(fā)深度優(yōu)先遍歷該樹。當(dāng)遍歷到結(jié)點（1，2）時，雖然它滿足約束條件，但還不是回答結(jié)點，則應(yīng)繼續(xù)深度遍歷；當(dāng)遍歷到葉子結(jié)點（1，2，5）時，由于它已是一個回答結(jié)點，則保存（或輸出）該結(jié)點，并回溯到其雙親結(jié)點，繼續(xù)深度遍歷；當(dāng)遍歷到結(jié)點（1，5）時，由于它已是葉子結(jié)點，但不滿足約束條件，故也需回溯。

　　3、回溯法的一般流程和技術(shù)

　　 在用回溯法求解有關(guān)問題的過程中，一般是一邊建樹，一邊遍歷該樹。在回溯法中我們一般采用非遞歸方法。下面，我們給出回溯法的非遞歸算法的一般流程：
　　
　　在用回溯法求解問題，也即在遍歷狀態(tài)空間樹的過程中，如果采用非遞歸方法，則我們一般要用到棧的數(shù)據(jù)結(jié)構(gòu)。這時，不僅可以用棧來表示正在遍歷的樹的結(jié)點，而且可以很方便地表示建立孩子結(jié)點和回溯過程。
　　例如在組合問題中，我們用一個一維數(shù)組Stack[ ]表示棧。開始�？眨瑒t表示了樹的根結(jié)點。如果元素1進(jìn)棧，則表示建立并遍歷（1）結(jié)點；這時如果元素2進(jìn)棧，則表示建立并遍歷（1，2）結(jié)點；元素3再進(jìn)棧，則表示建立并遍歷（1，2，3）結(jié)點。這時可以判斷它滿足所有約束條件，是問題的一個解，輸出（或保存）。這時只要棧頂元素（3）出棧，即表示從結(jié)點（1，2，3）回溯到結(jié)點（1，2）。

　　【問題】 組合問題
　　問題描述：找出從自然數(shù)1，2，…，n中任取r個數(shù)的所有組合。
　　采用回溯法找問題的解，將找到的組合以從小到大順序存于a[0]，a[1]，…，a[r-1]中，組合的元素滿足以下性質(zhì)：
　�。�1） a[i+1]>a[i]，后一個數(shù)字比前一個大；
　　（2） a[i]-i<=n-r+1。
　　按回溯法的思想，找解過程可以敘述如下：

　　 首先放棄組合數(shù)個數(shù)為r的條件，候選組合從只有一個數(shù)字1開始。因該候選解滿足除問題規(guī)模之外的全部條件，擴(kuò)大其規(guī)模，并使其滿足上述條件（1），候選組合改為1，2。繼續(xù)這一過程，得到候選組合1，2，3。該候選解滿足包括問題規(guī)模在內(nèi)的全部條件，因而是一個解。在該解的基礎(chǔ)上，選下一個候選解，因a[2]上的3調(diào)整為4，以及以后調(diào)整為5都滿足問題的全部要求，得到解1，2，4和1，2，5。由于對5不能再作調(diào)整，就要從a[2]回溯到a[1]，這時，a[1]=2，可以調(diào)整為3，并向前試探，得到解1，3，4。重復(fù)上述向前試探和向后回溯，直至要從a[0]再回溯時，說明已經(jīng)找完問題的全部解。按上述思想寫成程序如下：
　　【程序】
　　# define MAXN 100
　　int a[MAXN];
　　void comb(int m,int r)
　　{ int i,j;
　　 i=0;
　　 a[i]=1;
　　 do {
　　 if (a[i]-i<=m-r+1
　　 { if (i==r-1)
　　 { for (j=0;j　　 printf(“%4d”,a[j]);
　　 printf(“\n”);
　　 }
　　 a[i]++;
　　 continue;
　　 }
　　 else
　　 { if (i==0)
　　 return;
　　 a[--i]++;
　　 }
　　 } while (1)
　　}
　　
　　main()
　　{ comb(5,3);
　　}
　　【問題】 填字游戲
　　問題描述：在3×3個方格的方陣中要填入數(shù)字1到N（N≥10）內(nèi)的某9個數(shù)字，每個方格填一個整數(shù)，似的所有相鄰兩個方格內(nèi)的兩個整數(shù)之和為質(zhì)數(shù)。試求出所有滿足這個要求的各種數(shù)字填法。

　　可用試探發(fā)找到問題的解，即從第一個方格開始，為當(dāng)前方格尋找一個合理的整數(shù)填入，并在當(dāng)前位置正確填入后，為下一方格尋找可填入的合理整數(shù)。如不能為當(dāng)前方格找到一個合理的可填證書，就要回退到前一方格，調(diào)整前一方格的填入數(shù)。當(dāng)?shù)诰艂�方格也填入合理的整數(shù)后，就找到了一個解，將該解輸出，并調(diào)整第九個的填入的整數(shù)，尋找下一個解。

　　為找到一個滿足要求的9個數(shù)的填法，從還未填一個數(shù)開始，按某種順序（如從小到大的順序）每次在當(dāng)前位置填入一個整數(shù)，然后檢查當(dāng)前填入的整數(shù)是否能滿足要求。在滿足要求的情況下，繼續(xù)用同樣的方法為下一方格填入整數(shù)。如果最近填入的整數(shù)不能滿足要求，就改變填入的整數(shù)。如對當(dāng)前方格試盡所有可能的整數(shù)，都不能滿足要求，就得回退到前一方格，并調(diào)整前一方格填入的整數(shù)。如此重復(fù)執(zhí)行擴(kuò)展、檢查或調(diào)整、檢查，直到找到一個滿足問題要求的解，將解輸出。
　　回溯法找一個解的算法：
　　{ int m=0,ok=1;
　　 int n=8;
　　 do{
　　 if (ok) 擴(kuò)展;
　　 else 調(diào)整;
　　 ok=檢查前m個整數(shù)填放的合理性;
　　 } while ((!ok||m!=n)&&(m!=0))
　　 if (m!=0) 輸出解;
　　 else 輸出無解報告；
　　}
　　如果程序要找全部解，則在將找到的解輸出后，應(yīng)繼續(xù)調(diào)整最后位置上填放的整數(shù)，試圖去找下一個解。相應(yīng)的算法如下：
　　回溯法找全部解的算法：
　　{ int m=0,ok=1;
　　 int n=8;
　　 do{
　　 if (ok)
　　{ if (m==n)
　　{ 輸出解；
　　調(diào)整；
　　}
　　else 擴(kuò)展;
　　 }
　　 else 調(diào)整;
　　 ok=檢查前m個整數(shù)填放的合理性;
　　 } while (m!=0);
　　}
　　為了確保程序能夠終止，調(diào)整時必須保證曾被放棄過的填數(shù)序列不會再次實驗，即要求按某種有許模型生成填數(shù)序列。給解的候選者設(shè)定一個被檢驗的順序，按這個順序逐一形成候選者并檢驗。從小到大或從大到小，都是可以采用的方法。如擴(kuò)展時，先在新位置填入整數(shù)1，調(diào)整時，找當(dāng)前候選解中下一個還未被使用過的整數(shù)。將上述擴(kuò)展、調(diào)整、檢驗都編寫成程序，細(xì)節(jié)見以下找全部解的程序。
　　【程序】
　　# include
　　# define N 12
　　void write(int a[ ])
　　{ int i,j;
　　 for (i=0;i<3;i++)
　　 { for (j=0;j<3;j++)
　　 printf(“%3d”,a[3*i+j]);
　　 printf(“\n”);
　　 }
　　 scanf(“%*c”);
　　}
　　
　　int b[N+1];
　　int a[10];
　　int isprime(int m)
　　{ int i;
　　 int primes[ ]={2,3,5,7,11,17,19,23,29,-1};
　　 if (m==1||m%2=0) return 0;
　　 for (i=0;primes[i]>0;i++)
　　 if (m==primes[i]) return 1;
　　 for (i=3;i*i<=m;)
　　 { if (m%i==0) return 0;
　　 i+=2;
　　 }
　　 return 1;
　　}
　　
　　int checkmatrix[ ][3]={ {-1},{0,-1},{1,-1},{0,-1},{1,3,-1},
　　 {2,4,-1},{3,-1},{4,6,-1},{5,7,-1}};
　　int selectnum(int start)
　　{ int j;
　　 for (j=start;j<=N;j++)
　　 if (b[j]) return j
　　 return 0;
　　}
　　
　　int check(int pos)
　　{ int i,j;
　　 if (pos<0) return 0;
　　 for (i=0;(j=checkmatrix[pos][i])>=0;i++)
　　 if (!isprime(a[pos]+a[j])
　　 return 0;
　　 return 1;
　　}
　　
　　int extend(int pos)
　　{ a[++pos]=selectnum(1);
　　 b[a][pos]]=0;
　　 return pos;
　　}
　　
　　int change(int pos)
　　{ int j;
　　 while (pos>=0&&(j=selectnum(a[pos]+1))==0)
　　 b[a[pos--]]=1;
　　 if (pos<0) return –1
　　 b[a[pos]]=1;
　　 a[pos]=j;
　　 b[j]=0;
　　 return pos;
　　}
　　
　　void find()
　　{ int ok=0,pos=0;
　　 a[pos]=1;
　　 b[a[pos]]=0;
　　 do {
　　 if (ok)
　　 if (pos==8)
　　 { write(a);
　　 pos=change(pos);
　　 }
　　 else pos=extend(pos);
　　 else pos=change(pos);
　　 ok=check(pos);
　　 } while (pos>=0)
　　}
　　
　　void main()
　　{ int i;
　　 for (i=1;i<=N;i++)
　　 b[i]=1;
　　 find();
　　}
　　【問題】 n皇后問題
　　問題描述：求出在一個n×n的棋盤上，放置n個不能互相捕捉的國際象棋“皇后”的所有布局。
　　 這是來源于國際象棋的一個問題。皇后可以沿著縱橫和兩條斜線4個方向相互捕捉。如圖所示，一個皇后放在棋盤的第4行第3列位置上，則棋盤上凡打“×”的位置上的皇后就能與這個皇后相互捕捉。
　　
　　1 2 3 4 5 6 7 8
　　 × ×
　　× × ×
　　 × × ×
　　× × Q × × × × ×
　　 × × ×
　　× × ×
　　 × ×
　　 × ×
　　從圖中可以得到以下啟示：一個合適的解應(yīng)是在每列、每行上只有一個皇后，且一條斜線上也只有一個皇后。
　　 求解過程從空配置開始。在第1列至第m列為合理配置的基礎(chǔ)上，再配置第m+1列，直至第n列配置也是合理時，就找到了一個解。接著改變第n列配置，希望獲得下一個解。另外，在任一列上，可能有n種配置。開始時配置在第1行，以后改變時，順次選擇第2行、第3行、…、直到第n行。當(dāng)?shù)趎行配置也找不到一個合理的配置時，就要回溯，去改變前一列的配置。得到求解皇后問題的算法如下：
　　 { 輸入棋盤大小值n；
　　 m=0;
　　 good=1;
　　 do {
　　 if (good)
　　 if (m==n)
　　 { 輸出解；
　　 改變之，形成下一個候選解;
　　 }
　　 else 擴(kuò)展當(dāng)前候選接至下一列；
　　 else 改變之，形成下一個候選解；
　　 good=檢查當(dāng)前候選解的合理性；
　　 } while (m!=0);
　　 }
　　 在編寫程序之前，先確定邊式棋盤的數(shù)據(jù)結(jié)構(gòu)。比較直觀的方法是采用一個二維數(shù)組，但仔細(xì)觀察就會發(fā)現(xiàn)，這種表示方法給調(diào)整候選解及檢查其合理性帶來困難。更好的方法乃是盡可能直接表示那些常用的信息。對于本題來說，“常用信息”并不是皇后的具體位置，而是“一個皇后是否已經(jīng)在某行和某條斜線合理地安置好了”。因在某一列上恰好放一個皇后，引入一個一維數(shù)組（col[ ]），值col[i]表示在棋盤第i列、col[i]行有一個皇后。例如：col[3]=4，就表示在棋盤的第3列、第4行上有一個皇后。另外，為了使程序在找完了全部解后回溯到最初位置，設(shè)定col[0]的初值為0當(dāng)回溯到第0列時，說明程序已求得全部解，結(jié)束程序運行。

　　 為使程序在檢查皇后配置的合理性方面簡易方便，引入以下三個工作數(shù)組：
　�。�1） 數(shù)組a[ ]，a[k]表示第k行上還沒有皇后；
　�。�2） 數(shù)組b[ ]，b[k]表示第k列右高左低斜線上沒有皇后；
　�。�3） 數(shù)組 c[ ]，c[k]表示第k列左高右低斜線上沒有皇后；

　　棋盤中同一右高左低斜線上的方格，他們的行號與列號之和相同；同一左高右低斜線上的方格，他們的行號與列號之差均相同。

　　 初始時，所有行和斜線上均沒有皇后，從第1列的第1行配置第一個皇后開始，在第m列col[m]行放置了一個合理的皇后后，準(zhǔn)備考察第m+1列時，在數(shù)組a[ ]、b[ ]和c[ ]中為第m列，col[m]行的位置設(shè)定有皇后標(biāo)志；當(dāng)從第m列回溯到第m-1列，并準(zhǔn)備調(diào)整第m-1列的皇后配置時，清除在數(shù)組a[ ]、b[ ]和c[ ]中設(shè)置的關(guān)于第m-1列，col[m-1]行有皇后的標(biāo)志。一個皇后在m列，col[m]行方格內(nèi)配置是合理的，由數(shù)組a[ ]、b[ ]和c[ ]對應(yīng)位置的值都為1來確定。細(xì)節(jié)見以下程序：
　　【程序】
　　# include
　　# include
　　# define MAXN 20
　　int n,m,good;
　　int col[MAXN+1],a[MAXN+1],b[2*MAXN+1],c[2*MAXN+1];
　　
　　void main()
　　{ int j;
　　 char awn;
　　 printf(“Enter n: “); scanf(“%d”,&n);
　　 for (j=0;j<=n;j++) a[j]=1;
　　 for (j=0;j<=2*n;j++) cb[j]=c[j]=1;
　　 m=1; col[1]=1; good=1; col[0]=0;
　　 do {
　　 if (good)
　　 if (m==n)
　　 { printf(“列\(zhòng)t行”);
　　 for (j=1;j<=n;j++)
　　 printf(“%3d\t%d\n”,j,col[j]);
　　 printf(“Enter a character (Q/q for exit)!\n”);
　　 scanf(“%c”,&awn);
　　 if (awn==’Q’||awn==’q’) exit(0);
　　 while (col[m]==n)
　　 { m--;
　　 a[col[m]]=b[m+col[m]]=c[n+m-col[m]]=1;
　　 }
　　 col[m]++;
　　 }
　　 else
　　 { a[col[m]]=b[m+col[m]]=c[n+m-col[m]]=0;
　　 col[++m]=1;
　　 }
　　 else
　　 { while (col[m]==n)
　　 { m--;
　　 a[col[m]]=b[m+col[m]]=c[n+m-col[m]]=1;
　　 }
　　 col[m]++;
　　 }
　　 good=a[col[m]]&&b[m+col[m]]&&c[n+m-col[m]];
　　 } while (m!=0);
　　}
　　 試探法找解算法也常常被編寫成遞歸函數(shù)，下面兩程序中的函數(shù)queen_all()和函數(shù)queen_one()能分別用來解皇后問題的全部解和一個解。
　　【程序】
　　# include
　　# include
　　# define MAXN 20
　　int n;
　　int col[MAXN+1],a[MAXN+1],b[2*MAXN+1],c[2*MAXN+1];
　　void main()
　　{ int j;
　　 printf(“Enter n: “); scanf(“%d”,&n);
　　 for (j=0;j<=n;j++) a[j]=1;
　　 for (j=0;j<=2*n;j++) cb[j]=c[j]=1;
　　 queen_all(1,n);
　　}
　　
　　void queen_all(int k,int n)
　　{ int i,j;
　　 char awn;
　　 for (i=1;i<=n;i++)
　　 if (a[i]&&b[k+i]&&c[n+k-i])
　　 { col[k]=i;
　　 a[i]=b[k+i]=c[n+k-i]=0;
　　 if (k==n)
　　 { printf(“列\(zhòng)t行”);
　　 for (j=1;j<=n;j++)
　　 printf(“%3d\t%d\n”,j,col[j]);
　　 printf(“Enter a character (Q/q for exit)!\n”);
　　 scanf(“%c”,&awn);
　　 if (awn==’Q’||awn==’q’) exit(0);
　　 }
　　 queen_all(k+1,n);
　　 a[i]=b[k+i]=c[n+k-i];
　　 }
　　}
　　 采用遞歸方法找一個解與找全部解稍有不同，在找一個解的算法中，遞歸算法要對當(dāng)前候選解最終是否能成為解要有回答。當(dāng)它成為最終解時，遞歸函數(shù)就不再遞歸試探，立即返回；若不能成為解，就得繼續(xù)試探。設(shè)函數(shù)queen_one()返回1表示找到解，返回0表示當(dāng)前候選解不能成為解。細(xì)節(jié)見以下函數(shù)。
　　【程序】
　　# define MAXN 20
　　 int n;
　　 int col[MAXN+1],a[MAXN+1],b[2*MAXN+1],c[2*MAXN+1];
　　 int queen_one(int k,int n)
　　 { int i,found;
　　 i=found=0;
　　 While (!found&&i　　 { i++;
　　 if (a[i]&&b[k+i]&&c[n+k-i])
　　 { col[k]=i;
　　 a[i]=b[k+i]=c[n+k-i]=0;
　　 if (k==n) return 1;
　　 else
　　 found=queen_one(k+1,n);
　　 a[i]=b[k+i]=c[n+k-i]=1;
　　 }
　　 }
　　 return found;
　　 }

　　六、貪婪法

　　 貪婪法是一種不追求最優(yōu)解，只希望得到較為滿意解的方法。貪婪法一般可以快速得到滿意的解，因為它省去了為找最優(yōu)解要窮盡所有可能而必須耗費的大量時間。貪婪法常以當(dāng)前情況為基礎(chǔ)作最優(yōu)選擇，而不考慮各種可能的整體情況，所以貪婪法不要回溯。

　　 例如平時購物找錢時，為使找回的零錢的硬幣數(shù)最少，不考慮找零錢的所有各種發(fā)表方案，而是從最大面值的幣種開始，按遞減的順序考慮各幣種，先盡量用大面值的幣種，當(dāng)不足大面值幣種的金額時才去考慮下一種較小面值的幣種。這就是在使用貪婪法。這種方法在這里總是最優(yōu)，是因為銀行對其發(fā)行的硬幣種類和硬幣面值的巧妙安排。如只有面值分別為1、5和11單位的硬幣，而希望找回總額為15單位的硬幣。按貪婪算法，應(yīng)找1個11單位面值的硬幣和4個1單位面值的硬幣，共找回5個硬幣。但最優(yōu)的解應(yīng)是3個5單位面值的硬幣。

　　【問題】 裝箱問題

　　問題描述：裝箱問題可簡述如下：設(shè)有編號為0、1、…、n-1的n種物品，體積分別為v0、v1、…、vn-1。將這n種物品裝到容量都為V的若干箱子里。約定這n種物品的體積均不超過V，即對于0≤i＜n，有0＜vi≤V。不同的裝箱方案所需要的箱子數(shù)目可能不同。裝箱問題要求使裝盡這n種物品的箱子數(shù)要少。
　　 若考察將n種物品的集合分劃成n個或小于n個物品的所有子集，最優(yōu)解就可以找到。但所有可能劃分的總數(shù)太大。對適當(dāng)大的n，找出所有可能的劃分要花費的時間是無法承受的。為此，對裝箱問題采用非常簡單的近似算法，即貪婪法。該算法依次將物品放到它第一個能放進(jìn)去的箱子中，該算法雖不能保證找到最優(yōu)解，但還是能找到非常好的解。不失一般性，設(shè)n件物品的體積是按從大到小排好序的，即有v0≥v1≥…≥vn-1。如不滿足上述要求，只要先對這n件物品按它們的體積從大到小排序，然后按排序結(jié)果對物品重新編號即可。裝箱算法簡單描述如下：
　　{ 輸入箱子的容積；
　　 輸入物品種數(shù)n；
　　 按體積從大到小順序，輸入各物品的體積；
　　 預(yù)置已用箱子鏈為空；
　　 預(yù)置已用箱子計數(shù)器box_count為0；
　　 for (i=0;i　　 { 從已用的第一只箱子開始順序?qū)ふ夷芊湃胛锲穒 的箱子j；
　　 if （已用箱子都不能再放物品i）
　　 { 另用一個箱子，并將物品i放入該箱子；
　　 box_count++；
　　 }
　　 else
　　 將物品i放入箱子j；
　　 }
　　}
　　 上述算法能求出需要的箱子數(shù)box_count，并能求出各箱子所裝物品。下面的例子說明該算法不一定能找到最優(yōu)解，設(shè)有6種物品，它們的體積分別為：60、45、35、20、20和20單位體積，箱子的容積為100個單位體積。按上述算法計算，需三只箱子，各箱子所裝物品分別為：第一只箱子裝物品1、3；第二只箱子裝物品2、4、5；第三只箱子裝物品6。而最優(yōu)解為兩只箱子，分別裝物品1、4、5和2、3、6。

　　 若每只箱子所裝物品用鏈表來表示，鏈表首結(jié)點指針存于一個結(jié)構(gòu)中，結(jié)構(gòu)記錄尚剩余的空間量和該箱子所裝物品鏈表的首指針。另將全部箱子的信息也構(gòu)成鏈表。以下是按以上算法編寫的程序。
　　【程序】
　　# include
　　# include
　　typedef struct ele
　　{ int vno;
　　 struct ele *link;
　　} ELE;
　　typedef struct hnode
　　{ int remainder;
　　 ELE *head;
　　 Struct hnode *next;
　　} HNODE;
　　
　　void main()
　　{ int n, i, box_count, box_volume, *a;
　　 HNODE *box_h, *box_t, *j;
　　 ELE *p, *q;
　　 Printf(“輸入箱子容積\n”);
　　 Scanf(“%d”,&box_volume);
　　 Printf(“輸入物品種數(shù)\n”);
　　 Scanf(“%d”,&n);
　　 A=(int *)malloc(sizeof(int)*n);
　　 Printf(“請按體積從大到小順序輸入各物品的體積：”);
　　 For (i=0;i　　 Box_h=box_t=NULL;
　　 Box_count=0;
　　 For (i=0;i　　 { p=(ELE *)malloc(sizeof(ELE));
　　 p->vno=i;
　　 for (j=box_h;j!=NULL;j=j->next)
　　 if (j->remainder>=a[i]) break;
　　 if (j==NULL)
　　 { j=(HNODE *)malloc(sizeof(HNODE));
　　 j->remainder=box_volume-a[i];
　　 j->head=NULL;
　　 if (box_h==NULL) box_h=box_t=j;
　　 else box_t=boix_t->next=j;
　　 j->next=NULL;
　　 box_count++;
　　 }
　　 else j->remainder-=a[i];
　　 for (q=j->next;q!=NULL&&q->link!=NULL;q=q->link);
　　 if (q==NULL)
　　 { p->link=j->head;
　　 j->head=p;
　　 }
　　 else
　　 { p->link=NULL;
　　 q->link=p;
　　 }
　　 }
　　 printf(“共使用了%d只箱子”，box_count);
　　 printf(“各箱子裝物品情況如下：”);
　　 for (j=box_h,i=1;j!=NULL;j=j->next,i++)
　　 { printf(“第%2d只箱子，還剩余容積%4d，所裝物品有；\n”,I,j->remainder);
　　 for (p=j->head;p!=NULL;p=p->link)
　　 printf(“%4d”,p->vno+1);
　　 printf(“\n”);
　　 }
　　}
　　【問題】 馬的遍歷
　　問題描述：在8×8方格的棋盤上，從任意指定的方格出發(fā)，為馬尋找一條走遍棋盤每一格并且只經(jīng)過一次的一條路徑。

　　 馬在某個方格，可以在一步內(nèi)到達(dá)的不同位置最多有8個，如圖所示。如用二維數(shù)組board[ ][ ]表示棋盤，其元素記錄馬經(jīng)過該位置時的步驟號。另對馬的8種可能走法（稱為著法）設(shè)定一個順序，如當(dāng)前位置在棋盤的（i，j）方格，下一個可能的位置依次為（i+2，j+1）、（i+1，j+2）、（i-1，j+2）、（i-2，j+1）、（i-2，j-1）、（i-1，j-2）、（i+1，j-2）、（i+2，j-1），實際可以走的位置盡限于還未走過的和不越出邊界的那些位置。為便于程序的同意處理，可以引入兩個數(shù)組，分別存儲各種可能走法對當(dāng)前位置的縱橫增量。
　　 4 3
　　5 2
　　 馬
　　6 1
　　 7 0
　　
　　 對于本題，一般可以采用回溯法，這里采用Warnsdoff策略求解，這也是一種貪婪法，其選擇下一出口的貪婪標(biāo)準(zhǔn)是在那些允許走的位置中，選擇出口最少的那個位置。如馬的當(dāng)前位置（i，j）只有三個出口，他們是位置（i+2，j+1）、（i-2，j+1）和（i-1，j-2），如分別走到這些位置，這三個位置又分別會有不同的出口，假定這三個位置的出口個數(shù)分別為4、2、3，則程序就選擇讓馬走向（i-2，j+1）位置。

　　 由于程序采用的是一種貪婪法，整個找解過程是一直向前，沒有回溯，所以能非�？斓卣业浇�。但是，對于某些開始位置，實際上有解，而該算法不能找到解。對于找不到解的情況，程序只要改變8種可能出口的選擇順序，就能找到解。改變出口選擇順序，就是改變有相同出口時的選擇標(biāo)準(zhǔn)。以下程序考慮到這種情況，引入變量start，用于控制8種可能著法的選擇順序。開始時為0，當(dāng)不能找到解時，就讓start增1，重新找解。細(xì)節(jié)以下程序。
　　【程序】
　　# include
　　int delta_i[ ]={2,1,-1,-2,-2,-1,1,2};
　　int delta_j[ ]={1,2,2,1,-1,-2,-2,-1};
　　int board[8][8];
　　int exitn(int i,int j,int s,int a[ ])
　　{ int i1,j1,k,count;
　　 for (count=k=0;k<8;k++)
　　 { i1=i+delta_i[(s+k)%8];
　　 j1=i+delta_j[(s+k)%8];
　　 if (i1>=0&&i1<8&&j1>=0&&j1<8&&board[I1][j1]==0)
　　 a[count++]=(s+k)%8;
　　 }
　　 return count;
　　}
　　
　　int next(int i,int j,int s)
　　{ int m,k,mm,min,a[8],b[8],temp;
　　 m=exitn(i,j,s,a);
　　 if (m==0) return –1;
　　 for (min=9,k=0;k　　 { temp=exitn(I+delta_i[a[k]],j+delta_j[a[k]],s,b);
　　 if (temp　　 { min=temp;
　　kk=a[k];
　　 }
　　 }
　　 return kk;
　　}
　　
　　void main()
　　{ int sx,sy,i,j,step,no,start;
　　 for (sx=0;sx<8;sx++)
　　 for (sy=0;sy<8;sy++)
　　 { start=0;
　　 do {
　　 for (i=0;i<8;i++)
　　 for (j=0;j<8;j++)
　　 board[i][j]=0;
　　 board[sx][sy]=1;
　　 I=sx; j=sy;
　　 For (step=2;step<64;step++)
　　 { if ((no=next(i,j,start))==-1) break;
　　 I+=delta_i[no];
　　 j+=delta_j[no];
　　 board[i][j]=step;
　　 }
　　 if (step>64) break;
　　 start++;
　　 } while(step<=64)
　　 for (i=0;i<8;i++)
　　 { for (j=0;j<8;j++)
　　 printf(“%4d”,board[i][j]);
　　 printf(“\n\n”);
　　 }
　　 scanf(“%*c”);
　　 }
　　}

　　七、分治法

　　1、分治法的基本思想

　　任何一個可以用計算機(jī)求解的問題所需的計算時間都與其規(guī)模N有關(guān)。問題的規(guī)模越小，越容易直接求解，解題所需的計算時間也越少。例如，對于n個元素的排序問題，當(dāng)n=1時，不需任何計算；n=2時，只要作一次比較即可排好序；n=3時只要作3次比較即可，…。而當(dāng)n較大時，問題就不那么容易處理了。要想直接解決一個規(guī)模較大的問題，有時是相當(dāng)困難的。

　　分治法的設(shè)計思想是，將一個難以直接解決的大問題，分割成一些規(guī)模較小的相同問題，以便各個擊破，分而治之。

　　如果原問題可分割成k個子問題

　　2、分治法的適用條件

　　分治法所能解決的問題一般具有以下幾個特征：
　　（1）該問題的規(guī)�？s小到一定的程度就可以容易地解決；
　�。�2）該問題可以分解為若干個規(guī)模較小的相同問題，即該問題具有最優(yōu)子結(jié)構(gòu)性質(zhì)；
　�。�3）利用該問題分解出的子問題的解可以合并為該問題的解；
　�。�4）該問題所分解出的各個子問題是相互獨立的，即子問題之間不包含公共的子子問題。

　　上述的第一條特征是絕大多數(shù)問題都可以滿足的，因為問題的計算復(fù)雜性一般是隨著問題規(guī)模的增加而增加；第二條特征是應(yīng)用分治法的前提，它也是大多數(shù)問題可以滿足的，此特征反映了遞歸思想的應(yīng)用；第三條特征是關(guān)鍵，能否利用分治法完全取決于問題是否具有第三條特征，如果具備了第一條和第二條特征，而不具備第三條特征，則可以考慮貪心法或動態(tài)規(guī)劃法。第四條特征涉及到分治法的效率，如果各子問題是不獨立的，則分治法要做許多不必要的工作，重復(fù)地解公共的子問題，此時雖然可用分治法，但一般用動態(tài)規(guī)劃法較好。

　　3、分治法的基本步驟

　　分治法在每一層遞歸上都有三個步驟：
　�。�1）分解：將原問題分解為若干個規(guī)模較小，相互獨立，與原問題形式相同的子問題；
　�。�2）解決：若子問題規(guī)模較小而容易被解決則直接解，否則遞歸地解各個子問題；
　�。�3）合并：將各個子問題的解合并為原問題的解。
　　它的一般的算法設(shè)計模式如下：
　　Divide_and_Conquer（P）
　　if |P|≤n0
　　then return（ADHOC（P））
　　將P分解為較小的子問題P1、P2、…、Pk
　　for i←1 to k
　　do
　　yi ← Divide-and-Conquer（Pi） △ 遞歸解決Pi
　　T ← MERGE（y1，y2，…，yk） △ 合并子問題
　　Return（T）
　　其中 |P| 表示問題P的規(guī)模；n0為一閾值，表示當(dāng)問題P的規(guī)模不超過n0時，問題已容易直接解出，不必再繼續(xù)分解。ADHOC（P）是該分治法中的基本子算法，用于直接解小規(guī)模的問題P。因此，當(dāng)P的規(guī)模不超過n0時，直接用算法ADHOC（P）求解。
　　算法MERGE（y1，y2，…，yk）是該分治法中的合并子算法，用于將P的子問題P1、P2、…、Pk的相應(yīng)的解y1、y2、…、yk合并為P的解。
　　根據(jù)分治法的分割原則，原問題應(yīng)該分為多少個子問題才較適宜？各個子問題的規(guī)模應(yīng)該怎樣才為適當(dāng)？這些問題很難予以肯定的回答。但人們從大量實踐中發(fā)現(xiàn)，在用分治法設(shè)計算法時，最好使子問題的規(guī)模大致相同。換句話說，將一個問題分成大小相等的k個子問題的處理方法是行之有效的。許多問題可以取k=2。這種使子問題規(guī)模大致相等的做法是出自一種平衡子問題的思想，它幾乎總是比子問題規(guī)模不等的做法要好。