算法設計與分析第二版李春葆課后習題答案
1.1 第 1 章─概論 1.1.1 練習題 1. 下列關於算法的說法中正確的有（ ）。Ⅰ.求解某一類問題的算法是唯一的 Ⅱ.算法必須在有限步操作之后停止 Ⅲ.算法的每一步操作必須是明確的，不能有歧義或含義模糊Ⅳ.算法執行后一定產生確定的結果 A. 1 個 B.2 個 C.3 個 D.4 個 2. T(n)表示當輸入規模為 n 時的算法效率，以下算法效率最優的是（ ）。 A.T(n)= T(n-1)+1，T(1)=1 B.T(n)= 2n2 C.T(n)= T(n/2)+1，T(1)=1 D.T(n)=3nlog2n 3. 什么是算法？算法有哪些特征？ 4. 判斷一個大於 2 的正整數 n 是否為素數的方法有多種，給出兩種算法，說明其中一種算法更好的理由。 5. 證明以下關系成立： （1）10n2-2n=(n2) （2）2n+1=(2n) 6. 證明 O(f(n))+O(g(n))=O(max{f(n)，g(n)}) 。 7. 有一個含 n（n>2）個整數的數組 a，判斷其中是否存在出現次數超過所有元素一半的元素。 8. 一個字符串采用 string 對象存儲，設計一個算法判斷該字符串是否為回文。 9. 有一個整數序列，設計一個算法判斷其中是否存在兩個元素和恰好等於給定的整數 k。 10. 有兩個整數序列，每個整數序列中所有元素均不相同。設計一個算法求它們的公共元素，要求不使用 STL 的集合算法。 11. 正整數 n（n>1）可以寫成質數的乘積形式，稱為整數的質因數分解。例如， 12=2*2*3，18=2*3*3，11=11。設計一個算法求 n 這樣分解后各個質因數出現的次數，采用 vector 向量存放結果。 12. 有一個整數序列，所有元素均不相同，設計一個算法求相差最小的元素對的個數。如序列 4、1、2、3 的相差最小的元素對的個數是 3，其元素對是（1，2），（2，3）， （3，4）。 13. 有一個 map<string，int>容器，其中已經存放了較多元素。設計一個算法求出其中重復的 value 並且返回重復 value 的個數。 14. 重新做第 10 題，采用 map 容器存放最終結果。 15. 假設有一個含 n（n>1）個元素的 stack<int>棧容器 st，設計一個算法出棧從棧頂到棧底的第 k（1≤k≤n）個元素，其他棧元素不變。 1.1.2 練習題參考答案 1. 答：由於算法具有有窮性、確定性和輸出性，因而Ⅱ、Ⅲ、Ⅳ正確，而解決某一類問題的算法不一定是唯一的。答案為 C。 2. 答：選項 A 的時間復雜度為 O(n)。選項 B 的時間復雜度為 O(n2)。選項 C 的時間復雜度為 O(log2n)。選項 D 的時間復雜度為 O(nlog2n)。答案為 C。 3. 答：算法是求解問題的一系列計算步驟。算法具有有限性、確定性、可行性、輸入性和輸出性 5 個重要特征。 4. 答：兩種算法如下： #include <stdio.h> #include <math.h> bool isPrime1(int n) //方法 1 { for (int i=2;i<n;i++) if (n%i==0) return false; return true; } bool isPrime2(int n) //方法 2 { for (int i=2;i<=(int)sqrt(n);i++) if (n%i==0) return false; return true; } void main() { int n=5; printf("%d,%d\n",isPrime1(n),isPrime2(n)); } 方法 1 的時間復雜度為 O(n)，方法 2 的時間復雜度為 n，所以方法 2 更好。 5. 答：（1）當 n 足夠大時，(10n2-2n)/( n2)=10，所以 10n2-2n=(n2)。 （2）2n+1=2*2n=(2n)。 6. 證明：對於任意 f1(n)∈O(f(n)) ，存在正常數 c1 和正常數 n1，使得對所有 n≥n1， 有 f1(n)≤c1f(n) 。 類似地，對於任意 g1(n)∈O(g(n)) ，存在正常數 c2 和自然數 n2，使得對所有 n≥n2， 有 g1(n)≤c2g(n) 。 令 c3=max{c1，c2}，n3=max{n1，n2}，h(n)= max{f(n)，g(n)} 。則對所有的 n≥n3，有： f1(n) +g1(n)≤c1f(n) + c2g(n)≤c3f(n)+c3g(n)=c3(f(n)+g(n)) ≤c32max{f(n)，g(n)}=2c3h(n)=O(max{f(n)，g(n)})。 7. 解：先將 a 中元素遞增排序，再求出現次數最多的次數 maxnum，最后判斷是否滿足條件。對應的程序如下： #include <stdio.h> #include <algorithm> using namespace std; bool solve(int a[],int n,int &x) { sort(a,a+n); int maxnum=0; //遞增排序 //出現次數最多的次數 int num=1; int e=a[0]; for (int i=1;i<n;i++) { if (a[i]==e) { num++; if (num>maxnum) { maxnum=num; x=e; } } else { e=a[i]; num=1; } } if (maxnum>n/2) return true; else return false; } void main() { int a[]={2,2,2,4,5,6,2}; int n=sizeof(a)/sizeof(a[0]); int x; if (solve(a,n,x)) printf("出現次數超過所有元素一半的元素為%d\n",x); else printf("不存在出現次數超過所有元素一半的元素\n"); } 上述程序的執行結果如圖 1.1 所示。 圖 1.1 程序執行結果 8. 解：采用前后字符判斷方法，對應的程序如下： #include <iostream> #include <string> using namespace std; bool solve(string str) //判斷字符串 str 是否為回文 { int i=0,j=str.length()-1; while (i<j) { if (str[i]!=str[j]) return false; i++; j--; } return true; } void main() { cout << "求解結果" << endl; string str="abcd"; cout << " " << str << (solve(str)?"是回文":"不是回文") << endl; string str1="abba"; cout << " " << str1 << (solve(str1)?"是回文":"不是回文") << endl; } 上述程序的執行結果如圖 1.2 所示。 圖 1.2 程序執行結果 9. 解：先將 a 中元素遞增排序，然后從兩端開始進行判斷。對應的程序如下： #include <stdio.h> #include <algorithm> using namespace std; bool solve(int a[],int n,int k) { sort(a,a+n); //遞增排序 int i=0, j=n-1; while (i<j) //區間中存在兩個或者以上元素 { if (a[i]+a[j]==k) return true; else if (a[i]+a[j]<k) i++; else j--; } return false; } void main() { int a[]={1,2,4,5,3}; int n=sizeof(a)/sizeof(a[0]); printf("求解結果\n"); int k=9,i,j; if (solve(a,n,k,i,j)) printf(" 存在: %d+%d=%d\n",a[i],a[j],k); else printf(" 不存在兩個元素和為%d\n",k); int k1=10; if (solve(a,n,k1,i,j)) printf(" 存在: %d+%d=%d\n",a[i],a[j],k1); else printf(" 不存在兩個元素和為%d\n",k1); } 上述程序的執行結果如圖 1.3 所示。 圖 1.3 程序執行結果 10. 解：采用集合 set<int>存儲整數序列，集合中元素默認是遞增排序的，再采用二路歸並算法求它們的交集。對應的程序如下： #include <stdio.h> #include <set> using namespace std; void solve(set<int> s1,set<int> s2,set<int> &s3) //求交集 s3 { set<int>::iterator it1,it2; it1=s1.begin(); it2=s2.begin(); while (it1!=s1.end() && it2!=s2.end()) { if (*it1==*it2) { s3.insert(*it1); ++it1; ++it2; } else if (*it1<*it2) ++it1; else ++it2; } } void dispset(set<int> s) //輸出集合的元素 { set<int>::iterator it; for (it=s.begin();it!=s.end();++it) printf("%d ",*it); printf("\n"); } void main() { int a[]={3,2,4,8}; int n=sizeof(a)/sizeof(a[0]); set<int> s1(a,a+n); int b[]={1,2,4,5,3}; int m=sizeof(b)/sizeof(b[0]); set<int> s2(b,b+m); set<int> s3; solve(s1,s2,s3); printf("求解結果\n"); printf(" s1: "); dispset(s1); printf(" s2: "); dispset(s2); printf(" s3: "); dispset(s3); } 上述程序的執行結果如圖 1.4 所示。 圖 1.4 程序執行結果 11. 解：對於正整數 n，從 i=2 開始查找其質因數，ic 記錄質因數 i 出現的次數，當找到這樣質因數后，將（i，ic）作為一個元素插入到 vector 容器 v 中。最后輸出 v。對應的算法如下： #include <stdio.h> #include <vector> using namespace std; struct NodeType //vector 向量元素類型 { int p; //質因數 int pc; //質因數出現次數 }; void solve(int n,vector<NodeType> &v) //求 n 的質因數分解 { int i=2; int ic=0; NodeType e; do { if (n%i==0) { ic++; n=n/i; } else { if (ic>0) { e.p=i; e.pc=ic; v.push_back(e); } ic=0; i++; } } while (n>1 || ic!=0); } void disp(vector<NodeType> &v) //輸出 v { vector<NodeType>::iterator it; for (it=v.begin();it!=v.end();++it) printf(" 質因數%d 出現%d 次\n",it->p,it->pc); } void main() { vector<NodeType> v; int n=100; printf("n=%d\n",n); solve(n,v); disp(v); } 上述程序的執行結果如圖 1.5 所示。 圖 1.5 程序執行結果 12. 解：先遞增排序，再求相鄰元素差，比較求最小元素差，累計最小元素差的個數。對應的程序如下： #include <iostream> #include <algorithm> #include <vector> using namespace std; int solve(vector<int> &myv) //求 myv 中相差最小的元素對的個數 { sort(myv.begin(),myv.end()); //遞增排序 int ans=1; int mindif=myv[1]-myv[0]; for (int i=2;i<myv.size();i++) { if (myv[i]-myv[i-1]<mindif) { ans=1; mindif=myv[i]-myv[i-1]; } else if (myv[i]-myv[i-1]==mindif) ans++; } return ans; } void main() { int a[]={4,1,2,3}; int n=sizeof(a)/sizeof(a[0]); vector<int> myv(a,a+n); cout << "相差最小的元素對的個數: " << solve(myv) << endl; } 上述程序的執行結果如圖 1.6 所示。 圖 1.6 程序執行結果 13. 解：對於 map<string，int>容器 mymap，設計另外一個 map<int，int>容器 tmap， 將前者的 value 作為后者的關鍵字。遍歷 mymap，累計 tmap 中相同關鍵字的次數。一個參考程序及其輸出結果如下： #include <iostream> #include <map> #include <string> using namespace std; void main() { map<string,int> mymap; mymap.insert(pair<string,int>("Mary",80)); mymap.insert(pair<string,int>("Smith",82)); mymap.insert(pair<string,int>("John",80)); mymap.insert(pair<string,int>("Lippman",95)); mymap.insert(pair<string,int>("Detial",82)); map<string,int>::iterator it; map<int,int> tmap; for (it=mymap.begin();it!=mymap.end();it++) tmap[(*it).second]++; map<int，int>::iterator it1; cout << "求解結果" << endl; for (it1=tmap.begin();it1!=tmap.end();it1++) cout << " " << (*it1).first << ": " << (*it1).second << "次\n"; } 上述程序的執行結果如圖 1.7 所示。 圖 1.7 程序執行結果 14. 解：采用 map<int，int>容器 mymap 存放求解結果，第一個分量存放質因數，第二個分量存放質因數出現次數。對應的程序如下： #include <stdio.h> #include <map> using namespace std; void solve(int n,map<int,int> &mymap) //求 n 的質因數分解 else { if (ic>0) mymap[i]=ic; ic=0; i++; } } while (n>1 || ic!=0); } void disp(map<int,int> &mymap) //輸出 mymap { map<int,int>::iterator it; for (it=mymap.begin();it!=mymap.end();++it) printf(" 質因數%d 出現%d 次\n",it->first,it->second); } void main() { map<int,int> mymap; int n=12345; printf("n=%d\n",n); solve(n,mymap); disp(mymap); } 上述程序的執行結果如圖 1.8 所示。 圖 1.8 程序執行結果 15. 解：棧容器不能順序遍歷，為此創建一個臨時 tmpst 棧，將 st 的 k 個元素出棧並進棧到 tmpst 中，再出棧 tmpst 一次得到第 k 個元素，最后將棧 tmpst 的所有元素出棧並進棧到 st 中。對應的程序如下： #include <stdio.h> #include <stack> using namespace std; int solve(stack<int> &st,int k) //出棧第 k 個元素 { stack<int> tmpst; int e; for (int i=0;i<k;i++) //出棧 st 的 k 個元素並進 tmpst 棧 { e=st.top(); st.pop(); tmpst.push(e); } e=tmpst.top(); //求第 k 個元素 tmpst.pop(); while (!tmpst.empty()) //將 tmpst 的所有元素出棧並進棧 st { st.push(tmpst.top()); tmpst.pop(); } return e; } void disp(stack<int> &st) //出棧 st 的所有元素 { while (!st.empty()) { printf("%d ",st.top()); st.pop(); } printf("\n"); } void main() { stack<int> st; printf("進棧元素 1,2,3,4\n"); st.push(1); st.push(2); st.push(3); st.push(4); int k=3; int e=solve(st,k); printf("出棧第%d 個元素是: %d\n",k,e); printf("st 中元素出棧順序: "); disp(st); } 上述程序的執行結果如圖 1.9 所示。 圖 1.9 程序執行結果 1.2 第 2 章─遞歸算法設計技術 1.2.1 練習題 1. 什么是直接遞歸和間接遞歸？消除遞歸一般要用到什么數據結構？ 2. 分析以下程序的執行結果： #include <stdio.h> void f(int n,int &m) { if (n<1) return; else { printf("調用f(%d,%d)前,n=%d,m=%d\n",n-1,m-1,n,m); n--; m--; f(n-1,m); printf("調用f(%d,%d)后:n=%d,m=%d\n",n-1,m-1,n,m); } } void main() { int n=4,m=4; f(n,m); } 3. 采用直接推導方法求解以下遞歸方程： T(1)=1 T(n)=T(n-1)+n 當 n>1 4. 采用特征方程方法求解以下遞歸方程： H(0)=0 H(1)=1 H(2)=2 H(n)=H(n-1)+9H(n-2)-9H(n-3) 當 n>2 5. 采用遞歸樹方法求解以下遞歸方程： T(1)=1 T(n)=4T(n/2)+n 當 n>1 6. 采用主方法求解以下題的遞歸方程。 T(n)=1 當 n=1 T(n)=4T(n/2)+n2 當 n>1 7. 分析求斐波那契 f(n)的時間復雜度。 8. 數列的首項 a1=0，后續奇數項和偶數項的計算公式分別為 a2n=a2n-1+2，a2n+1=a2n- 1+a2n-1，寫出計算數列第 n 項的遞歸算法。 9. 對於一個采用字符數組存放的字符串 str，設計一個遞歸算法求其字符個數（長度）。 10. 對於一個采用字符數組存放的字符串 str，設計一個遞歸算法判斷 str 是否為回文。 11. 對於不帶頭結點的單鏈表 L，設計一個遞歸算法正序輸出所有結點值。 12. 對於不帶頭結點的單鏈表 L，設計一個遞歸算法逆序輸出所有結點值。 13. 對於不帶頭結點的非空單鏈表 L，設計一個遞歸算法返回最大值結點的地址（假設這樣的結點唯一）。 14. 對於不帶頭結點的單鏈表 L，設計一個遞歸算法返回第一個值為 x 的結點的地址，沒有這樣的結點時返回 NULL。 15. 對於不帶頭結點的單鏈表 L，設計一個遞歸算法刪除第一個值為 x 的結點。 16. 假設二叉樹采用二叉鏈存儲結構存放，結點值為 int 類型，設計一個遞歸算法求二叉樹 bt 中所有葉子結點值之和。 17. 假設二叉樹采用二叉鏈存儲結構存放，結點值為 int 類型，設計一個遞歸算法求二叉樹 bt 中所有結點值大於等於 k 的結點個數。 18. 假設二叉樹采用二叉鏈存儲結構存放，所有結點值均不相同，設計一個遞歸算法求值為 x 的結點的層次（根結點的層次為 1），沒有找到這樣的結點時返回 0。 1.2.2 練習題參考答案 1. 答：一個 f 函數定義中直接調用 f 函數自己，稱為直接遞歸。一個 f 函數定義中調用 g 函數，而 g 函數的定義中調用 f 函數，稱為間接遞歸。消除遞歸一般要用棧實現。 2. 答：遞歸函數f(n，m)中，n是非引用參數，m是引用參數，所以遞歸函數的狀態為 （n）。程序執行結果如下： 調用f(3,3)前,n=4,m=4 調用f(1,2)前,n=2,m=3 調用f(0,1)后,n=1,m=2 調用f(2,1)后,n=3,m=2 3. 解：求 T(n)的過程如下： T(n)=T(n-1)+n=[T(n-2)+n-1)]+n=T(n-2)+n+(n-1) =T(n-3)+n+(n-1)+(n-2) =… =T(1)+n+(n-1)+…+2 =n+(n-1)+ +…+2+1=n(n+1)/2=O(n2)。 4. 解：整數一個常系數的線性齊次遞推式，用 xn 代替 H(n)，有：xn=xn-1+9xn-2-9xn-3， 兩邊同時除以 xn-3，得到：x3=x2+9x-9，即 x3-x2-9x+9=0。 x3-x2-9x+9=x(x2-9)-(x2-9)=(x-1)(x2-9)=(x-1)(x+3)(x-3)=0。得到 r1=1，r2=-3，r3=3 則遞歸方程的通解為：H(n)=c1+c2(-3)n+c33n 代入 H(0)=0，有 c1+c2+c3=0 代入 H(1)=1，有 c1-3c2+3c3=1 代入 H(2)=2，有 c1+9c2+9c3=2 ( ‒ 1)n ‒ 1 n ‒ 1 1 求出：c1=-1/4，c2=-1/12，c3=1/3，H(n)=c1+c2(-3)n+c33n=( 4 + 1)3 ‒ 4。 5. 解：構造的遞歸樹如圖 1.10 所示，第 1 層的問題規模為 n，第 2 的層的子問題的問題規模為 n/2，依此類推，當展開到第 k+1 層，其規模為 n/2k=1，所以遞歸樹的高度為log2n+1。 第1層有1個結點，其時間為n，第2層有4個結點，其時間為4(n/2)=2n，依次類推，第k 層有4k-1個結點，每個子問題規模為n/2k-1，其時間為4k-1(n/2k-1)=2k-1n。葉子結點的個數為n 個，其時間為n。將遞歸樹每一層的時間加起來，可得： T(n)=n+2n+…+ 2k-1n+…+n≈𝑛 ∗ 2log2n=O(n2)。 (n/2) n n (n/2) (n/2) (n/2) 2n 高度h為log 2n+1 (n/22) (n/22) (n/22) (n/22) 22n … … … … 1 1 1 1 n 圖 1.10 一棵遞歸樹 6. 解：采用主方法求解，這里 a=4，b=2，f(n)=n2。 logba log24 2 因此，𝑛 logba =𝑛 2 =n ，它與 f(n)一樣大，滿足主定理中的情況（2），所以 T(n)=O( 𝑛 log2n)=O(n log2n)。 7. 解：設求斐波那契 f(n)的時間為 T(n)，有以下遞推式： T(1)=T(2) T(n)=T(n-1)+T(n-2)+1 當 n>2 其中，T(n)式中加 1 表示一次加法運算的時間。 不妨先求 T1(1)=T1(2)=1，T1(n)=T1(n-1)+T1(n-2)，按《教程》例 2.14 的方法可以求 出： 1 1 5 n 1 1 5 n 1 1 5 n T1(n)= ≈ = 1 1 5 n 所以 T(n)=T1(n)+1≈ +1=O(φn)，其中 φ= 。 8. 解：設 f(m)計算數列第 m 項值。 當 m 為偶數時，不妨設 m=2n，則 2n-1=m-1，所以有 f(m)=f(m-1)+2。 當 m 為奇數時，不妨設 m=2n+1，則 2n-1=m-2，2n=m-1，所以有 f(m)=f(m-2)+f(m- 1)-1。 對應的遞歸算法如下： int f(int m) { if (m==1) return 0; if (m%2==0) return f(m-1)+2; else return f(m-2)+f(m-1)-1; } 9. 解：設 f(str)返回字符串 str 的長度，其遞歸模型如下： f(str)=0 當*str='\0'時 f(str)=f(str+1)+1 其他情況 對應的遞歸程序如下： #include <iostream> using namespace std; int Length(char *str) //求str的字符個數 { if (*str=='\0') return 0; else return Length(str+1)+1; } void main() { char str[]="abcd"; cout << str << "的長度: " << Length(str) << endl; } 上述程序的執行結果如圖 1.11 所示。 圖 1.11 程序執行結果 10. 解：設 f(str，n)返回含 n 個字符的字符串 str 是否為回文，其遞歸模型如下： f(str，n)=true 當 n=0 或者 n=1 時 f(str，n)=flase 當 str[0]≠str[n-1]時 f(str，n)=f(str+1，n-2) 其他情況 對應的遞歸算法如下： #include <stdio.h> #include <string.h> bool isPal(char *str,int n) //str 回文判斷算法 { if (n==0 || n==1) return true; if (str[0]!=str[n-1]) return false; return isPal(str+1,n-2); } void disp(char *str) { int n=strlen(str); if (isPal(str,n)) printf(" %s是回文\n",str); else printf(" %s不是回文\n",str); } void main() { printf("求解結果\n"); disp("abcba"); disp("a"); disp("abc"); } 上述程序的執行結果如圖 1.12 所示。 圖 1.12 程序執行結果 11. 解：設 f(L)正序輸出單鏈表 L 的所有結點值，其遞歸模型如下： f(L) ≡ 不做任何事情 當 L=NULL f(L) ≡ 輸出 L->data; f(L->next); 當 L≠NULL 時對應的遞歸程序如下： #include "LinkList.cpp" //包含單鏈表的基本運算算法 void dispLink(LinkNode *L) //正序輸出所有結點值 { if (L==NULL) return; else { printf("%d ",L->data); dispLink(L->next); } } void main() { int a[]={1,2,5,2,3,2}; int n=sizeof(a)/sizeof(a[0]); LinkNode *L; CreateList(L,a,n); //由a[0..n-1]創建不帶頭結點的單鏈表 printf("正向L: "); dispLink(L); printf("\n"); Release(L); //銷毀單鏈表 } 上述程序的執行結果如圖 1.13 所示。 圖 1.13 程序執行結果 12. 解：設 f(L)逆序輸出單鏈表 L 的所有結點值，其遞歸模型如下： f(L) ≡ 不做任何事情 當 L=NULL f(L) ≡ f(L->next); 輸出 L->data 當 L≠NULL 時對應的遞歸程序如下： #include "LinkList.cpp" //包含單鏈表的基本運算算法 void Revdisp(LinkNode *L) //逆序輸出所有結點值 { if (L==NULL) return; else { Revdisp(L->next); printf("%d ",L->data); } } void main() { int a[]={1,2,5,2,3,2}; int n=sizeof(a)/sizeof(a[0]); LinkNode *L; CreateList(L,a,n); printf("反向L: "); Revdisp(L); printf("\n"); Release(L); } 上述程序的執行結果如圖 1.14 所示。 圖 1.14 程序執行結果 13. 解：設 f(L)返回單鏈表 L 中值最大結點的地址，其遞歸模型如下： f(L) = L 當 L 只有一個結點時 f(L) = MAX{f(L->next)，L->data} 其他情況 對應的遞歸程序如下： #include "LinkList.cpp" //包含單鏈表的基本運算算法 LinkNode *Maxnode(LinkNode *L) //返回最大值結點的地址 { if (L->next==NULL) return L; //只有一個結點時 else { LinkNode *maxp; maxp=Maxnode(L->next); if (L->data>maxp->data) return L; else return maxp; } } void main() { int a[]={1,2,5,2,3,2}; int n=sizeof(a)/sizeof(a[0]); LinkNode *L,*p; CreateList(L,a,n); p=Maxnode(L); printf("最大結點值: %d\n",p->data); Release(L); } 上述程序的執行結果如圖 1.15 所示。 圖 1.15 程序執行結果 14. 解：設 f(L，x)返回單鏈表 L 中第一個值為 x 的結點的地址，其遞歸模型如下： f(L，x) = NULL 當 L=NULL 時 f(L，x) = L 當 L≠NULL 且 L->data=x 時 f(L，x) = f(L->next，x) 其他情況 對應的遞歸程序如下： #include "LinkList.cpp" //包含單鏈表的基本運算算法 LinkNode *Firstxnode(LinkNode *L,int x) //返回第一個值為 x 的結點的地址 { if (L==NULL) return NULL; if (L->data==x) return L; else return Firstxnode(L->next,x); } void main() { int a[]={1,2,5,2,3,2}; int n=sizeof(a)/sizeof(a[0]); LinkNode *L,*p; CreateList(L,a,n); int x=2; p=Firstxnode(L,x); printf("結點值: %d\n",p->data); Release(L); } 上述程序的執行結果如圖 1.16 所示。 圖 1.16 程序執行結果 15. 解：設 f(L，x)刪除單鏈表 L 中第一個值為 x 的結點，其遞歸模型如下： f(L，x) ≡ 不做任何事情 當 L=NULL f(L，x) ≡ 刪除 L 結點，L=L->next 當 L≠NULL 且 L->data=x f(L，x) ≡ f(L->next，x) 其他情況 對應的遞歸程序如下： #include "LinkList.cpp" //包含單鏈表的基本運算算法 void Delfirstx(LinkNode *&L,int x) //刪除單鏈表 L 中第一個值為 x 的結點 { if (L==NULL) return; if (L->data==x) { LinkNode *p=L; L=L->next; free(p); } else Delfirstx(L->next,x); } void main() { int a[]={1,2,5,2,3,2}; int n=sizeof(a)/sizeof(a[0]); LinkNode *L; CreateList(L,a,n); printf("刪除前L: "); DispList(L); int x=2; printf("刪除第一個值為%d的結點\n",x); Delfirstx(L,x); printf("刪除后L: "); DispList(L); Release(L); } 上述程序的執行結果如圖 1.17 所示。 圖 1.17 程序執行結果 16. 解：設 f(bt)返回二叉樹 bt 中所有葉子結點值之和，其遞歸模型如下： f(bt)=0 當 bt=NULL f(bt)=bt->data 當 bt≠NULL 且 bt 結點為葉子結點 f(bt)=f(bt->lchild)+f(bt->rchild) 其他情況 對應的遞歸程序如下： #include "Btree.cpp" //包含二叉樹的基本運算算法 int LeafSum(BTNode *bt) //二叉樹 bt 中所有葉子結點值之和 { if (bt==NULL) return 0; if (bt->lchild==NULL && bt->rchild==NULL) return bt->data; int lsum=LeafSum(bt->lchild); int rsum=LeafSum(bt->rchild); return lsum+rsum; } void main() { BTNode *bt; Int a[]={5,2,3,4,1,6}; //先序序列 Int b[]={2,3,5,1,4,6}; //中序序列 int n=sizeof(a)/sizeof(a[0]); bt=CreateBTree(a,b,n); //由a和b構造二叉鏈bt printf("二叉樹bt:"); DispBTree(bt); printf("\n"); printf("所有葉子結點值之和: %d\n",LeafSum(bt)); DestroyBTree(bt); //銷毀樹bt } 上述程序的執行結果如圖 1.18 所示。 圖 1.18 程序執行結果 17. 解：設 f(bt，k)返回二叉樹 bt 中所有結點值大於等於 k 的結點個數，其遞歸模型如下： f(bt，k)=0 當 bt=NULL f(bt，k)=f(bt->lchild，k)+f(bt->rchild，k)+1 當 bt≠NULL 且 bt->data≥k f(bt，k)=f(bt->lchild，k)+f(bt->rchild，k) 其他情況 對應的遞歸程序如下： #include "Btree.cpp" //包含二叉樹的基本運算算法 int Nodenum(BTNode *bt,int k) //大於等於 k 的結點個數 { if (bt==NULL) return 0; int lnum=Nodenum(bt->lchild,k); int rnum=Nodenum(bt->rchild,k); if (bt->data>=k) return lnum+rnum+1; else return lnum+rnum; } void main() { BTNode *bt; Int a[]={5,2,3,4,1,6}; Int b[]={2,3,5,1,4,6}; int n=sizeof(a)/sizeof(a[0]); bt=CreateBTree(a,b,n); //由a和b構造二叉鏈bt printf("二叉樹bt:"); DispBTree(bt); printf("\n"); int k=3; printf("大於等於%d的結點個數: %d\n",k,Nodenum(bt,k)); DestroyBTree(bt); //銷毀樹bt } 上述程序的執行結果如圖 1.19 所示。 圖 1.19 程序執行結果 18. 解：設 f(bt，x，h)返回二叉樹 bt 中 x 結點的層次，其中 h 表示 bt 所指結點的層次，初始調用時，bt 指向根結點，h 置為 1。其遞歸模型如下： f(bt，x，h)=0 當 bt=NULL f(bt，x，h)=h 當 bt≠NULL 且 bt->data=x f(bt，x，h) =l 當 l=f(bt->lchild，x，h+1)≠0 f(bt，x，h) =f(bt->rchild，x，h+1) 其他情況 對應的遞歸程序如下： #include "Btree.cpp" //包含二叉樹的基本運算算法 int Level(BTNode *bt,int x,int h) //求二叉樹 bt 中 x 結點的層次 { //初始調用時：bt 為根，h 為 1 if (bt==NULL) return 0; if (bt->data==x) //找到 x 結點，返回 h return h; else { int l=Level(bt->lchild,x,h+1); //在左子樹中查找 if (l!=0) //在左子樹中找到，返回其層次 l return l; else return Level(bt->rchild,x,h+1);//返回在右子樹的查找結果 } } void main() { BTNode *bt; Int a[]={5,2,3,4,1,6}; Int b[]={2,3,5,1,4,6}; int n=sizeof(a)/sizeof(a[0]); bt=CreateBTree(a,b,n); //由 a 和 b 構造二叉鏈 bt printf("二叉樹 bt:"); DispBTree(bt); printf("\n"); int x=1; printf("%d 結點的層次: %d\n",x,Level(bt,x,1)); DestroyBTree(bt); //銷毀樹 bt } 上述程序的執行結果如圖 1.20 所示。 圖 1.20 程序執行結果 1.3 第 3 章─分治法 1.3.1 練習題 1. 分治法的設計思想是將一個難以直接解決的大問題分割成規模較小的子問題，分別解決子問題，最后將子問題的解組合起來形成原問題的解。這要求原問題和子問題 （ ）。 A.問題規模相同，問題性質相同B.問題規模相同，問題性質不同C.問題規模不同，問題性質相同D.問題規模不同，問題性質不同 2. 在尋找 n 個元素中第 k 小元素問題中，如快速排序算法思想，運用分治算法對 n 個元素進行划分，如何選擇划分基准？下面（ ）答案解釋最合理。 A. 隨機選擇一個元素作為划分基准 B. 取子序列的第一個元素作為划分基准C.用中位數的中位數方法尋找划分基准 D.以上皆可行。但不同方法，算法復雜度上界可能不同 3. 對於下列二分查找算法，以下正確的是（ ）。 A. int binarySearch(int a[], int n, int x) { int low=0, high=n-1; while(low<=high) { int mid=(low+high)/2; if(x==a[mid]) return mid; if(x>a[mid]) low=mid; else high=mid; } return –1; } B. int binarySearch(int a[], int n, int x) { int low=0, high=n-1; while(low+1!=high) { int mid=(low+high)/2; if(x>=a[mid]) low=mid; else high=mid; } if(x==a[low]) return low; else return –1; } C. int binarySearch (int a[], int n, int x) { int low=0, high=n-1; while(low<high-1) { int mid=(low+high)/2; if(x<a[mid]) high=mid; } else low=mid; if(x==a[low]) return low; else return –1; } D. int binarySearch(int a[], int n, int x) { if(n > 0 && x >= a[0]) { int low = 0, high = n-1; while(low < high) { int mid=(low+high+1)/2; if(x < a[mid]) high=mid-1; else low=mid; } if(x==a[low]) return low; } return –1; } 4. 快速排序算法是根據分治策略來設計的，簡述其基本思想。 5. 假設含有 n 個元素的待排序的數據 a 恰好是遞減排列的，說明調用 QuickSort(a， 0，n-1)遞增排序的時間復雜度為 O(n2)。 6. 以下哪些算法采用分治策略： （1） 堆排序算法 （2） 二路歸並排序算法 （3） 折半查找算法 （4） 順序查找算法 7. 適合並行計算的問題通常表現出哪些特征？ 8. 設有兩個復數 x=a+bi 和 y=c+di。復數乘積 xy 可以使用 4 次乘法來完成，即 xy=(ac-bd)+(ad+bc)i。設計一個僅用 3 次乘法來計算乘積 xy 的方法。 9. 有 4 個數組 a、b、c 和 d，都已經排好序，說明找出這 4 個數組的交集的方法。 10. 設計一個算法，采用分治法求一個整數序列中的最大最小元素。 11. 設計一個算法，采用分治法求 xn。 12. 假設二叉樹采用二叉鏈存儲結構進行存儲。設計一個算法采用分治法求一棵二叉樹 bt 的高度。 13. 假設二叉樹采用二叉鏈存儲結構進行存儲。設計一個算法采用分治法求一棵二叉樹 bt 中度為 2 的結點個數。 14. 有一種二叉排序樹，其定義是空樹是一棵二叉排序樹，若不空，左子樹中所有結點值小於根結點值，右子樹中所有結點值大於根結點值，並且左右子樹都是二叉排序樹。現在該二叉排序樹采用二叉鏈存儲，采用分治法設計查找值為 x 的結點地址，並分析算法的最好的平均時間復雜度。 15. 設有 n 個互不相同的整數，按遞增順序存放在數組 a[0..n-1]中，若存在一個下標i（0≤i<n），使得 a[i]=i。設計一個算法以 O(log2n)時間找到這個下標 i。 16. 請你模仿二分查找過程設計一個三分查找算法。分析其時間復雜度。 17. 對於大於 1 的正整數 n，可以分解為 n=x1*x2*…*xm，其中 xi≥2。例如，n=12 時有 8 種 不 同 的 分 解 式 ：12=12，12=6*2，12=4*3，12=3*4，12=3*2*2，12=2*6， 12=2*3*2，12=2*2*3，設計一個算法求 n 的不同分解式個數。 18. 設計一個基於 BSP 模型的並行算法，假設有 p 台處理器，計算整數數組 a[0..n-1] 的所有元素之和。並分析算法的時間復雜度。 1.3.2 練習題參考答案 1. 答：C。 2. 答：D。 3. 答：以 a[]={1，2，3，4，5}為例說明。選項 A 中在查找 5 時出現死循環。選項 B 中在查找 5 時返回-1。選項 C 中在查找 5 時返回-1。選項 D 正確。 4. 答：對於無序序列 a[low..high]進行快速排序，整個排序為“大問題”。選擇其中的一個基准 base=a[i]（通常以序列中第一個元素為基准），將所有小於等於 base 的元素移動到它的前面，所有大於等於 base 的元素移動到它的后面，即將基准歸位到 a[i]，這樣產生a[low..i-1]和 a[i+1..high]兩個無序序列，它們的排序為“小問題”。當 a[low..high]序列只有一個元素或者為空時對應遞歸出口。 所以快速排序算法就是采用分治策略，將一個“大問題”分解為兩個“小問題”來求解。由於元素都是在 a 數組中，其合並過程是自然產生的，不需要特別設計。 5. 答：此時快速排序對應的遞歸樹高度為 O(n)，每一次划分對應的時間為 O(n)，所以整個排序時間為 O(n2)。 6. 答：其中二路歸並排序和折半查找算法采用分治策略。 7. 答：適合並行計算的問題通常表現出以下特征： （1） 將工作分離成離散部分，有助於同時解決。例如，對於分治法設計的串行算法，可以將各個獨立的子問題並行求解，最后合並成整個問題的解，從而轉化為並行算法。 （2） 隨時並及時地執行多個程序指令。 （3） 多計算資源下解決問題的耗時要少於單個計算資源下的耗時。 8. 答：xy=(ac-bd)+((a+b)(c+d)-ac-bd)i。由此可見，這樣計算 xy 只需要 3 次乘法（即 ac、bd 和(a+b)(c+d)乘法運算）。 9. 答：采用基本的二路歸並思路，先求出 a、b 的交集 ab，再求出 c、d 的交集 cd， 最后求出 ab 和 cd 的交集，即為最后的結果。也可以直接采用 4 路歸並方法求解。 10. 解：采用類似求求一個整數序列中的最大次大元素的分治法思路。對應的程序如下： #include <stdio.h> #define max(x,y) ((x)>(y)?(x):(y)) #define min(x,y) ((x)<(y)?(x):(y)) void MaxMin(int a[],int low,int high,int &maxe,int &mine) //求a中最大最小元素 { if (low==high) //只有一個元素 { maxe=a[low]; mine=a[low]; } else if (low==high-1) //只有兩個元素 { maxe=max(a[low],a[high]); mine=min(a[low],a[high]); } else //有兩個以上元素 { int mid=(low+high)/2; int lmaxe,lmine; MaxMin(a,low,mid,lmaxe,lmine); int rmaxe,rmine; MaxMin(a,mid+1,high,rmaxe,rmine); maxe=max(lmaxe,rmaxe); mine=min(lmine,rmine); } } void main() { int a[]={4,3,1,2,5}; int n=sizeof(a)/sizeof(a[0]); int maxe,mine; MaxMin(a,0,n-1,maxe,mine); printf("Max=%d, Min=%d\n",maxe,mine); } 上述程序的執行結果如圖 1.21 所示。 圖 1.21 程序執行結果 11. 解：設 f(x，n)=xn，采用分治法求解對應的遞歸模型如下： f(x，n)=x 當 n=1 f(x，n)=f(x，n/2)*f(x，n/2) 當 n 為偶數時 f(x，n)=f(x，(n-1)/2)*f(x，(n-1)/2)*x 當 n 為奇數時 對應的遞歸程序如下： #include <stdio.h> double solve(double x,int n) //求x^n { double fv; if (n==1) return x; if (n%2==0) { fv=solve(x,n/2); return fv*fv; } else { fv=solve(x,(n-1)/2); return fv*fv*x; } } void main() { double x=2.0; printf("求解結果:\n"); for (int i=1;i<=10;i++) printf(" %g^%d=%g\n",x,i,solve(x,i)); } 上述程序的執行結果如圖 1.22 所示。 圖 1.22 程序執行結果 12. 解：設 f(bt)返回二叉樹 bt 的高度，對應的遞歸模型如下： f(bt)=0 f(bt)=MAX{f(bt->lchild)，f(bt->rchild)}+1 對應的程序如下： #include "Btree.cpp" 當 bt=NULL 其他情況 //包含二叉樹的基本運算算法 int Height(BTNode *bt) { if (bt==NULL) return 0; int lh=Height(bt->lchild); //求二叉樹bt的高度 //子問題1 int rh=Height(bt->rchild); //子問題2 if (lh>rh) return lh+1; else return rh+1; } void main() //合並 { BTNode *bt; Int a[]={5,2,3,4,1,6}; Int b[]={2,3,5,1,4,6}; int n=sizeof(a)/sizeof(a[0]); bt=CreateBTree(a,b,n); //由a和b構造二叉鏈bt printf("二叉樹bt:"); DispBTree(bt); printf("\n"); printf("bt的高度: %d\n",Height(bt)); } DestroyBTree(bt); //銷毀樹bt 上述程序的執行結果如圖 1.23 所示。 圖 1.23 程序執行結果 13. 解：設 f(bt)返回二叉樹 bt 中度為 2 的結點個數，對應的遞歸模型如下： f(bt)=0 當 bt=NULL f(bt)=f(bt->lchild)+f(bt->rchild)+1 若 bt≠NULL 且 bt 為雙分支結點 f(bt)=f(bt->lchild)+f(bt->rchild) 其他情況 對應的算法如下： #include "Btree.cpp" //包含二叉樹的基本運算算法 int Nodes(BTNode *bt) //求 bt 中度為 2 的結點個數 { int n=0; if (bt==NULL) return 0; if (bt->lchild!=NULL && bt->rchild!=NULL) n=1; return Nodes(bt->lchild)+Nodes(bt->rchild)+n; } void main() { BTNode *bt; Int a[]={5,2,3,4,1,6}; Int b[]={2,3,5,1,4,6}; int n=sizeof(a)/sizeof(a[0]); bt=CreateBTree(a,b,n); //由a和b構造二叉鏈bt printf("二叉樹bt:"); DispBTree(bt); printf("\n"); printf("bt中度為2的結點個數: %d\n",Nodes(bt)); DestroyBTree(bt); //銷毀樹bt } 上述程序的執行結果如圖 1.24 所示。 圖 1.24 程序執行結果 14. 解：設 f(bt，x)返回在二叉排序樹 bt 得到的值為 x 結點的地址，若沒有找到返回空，對應的遞歸模型如下： f(bt，x)=NULL 當 bt=NULL f(bt，x)=bt 當 bt≠NULL 且 x=bt->data f(bt，x)=f(bt->lchild，x) 當 x>bt->data f(bt，x)=f(bt->rchild，x) 當 x<bt->data 對應的程序如下： #include "Btree.cpp" //包含二叉樹的基本運算算法 BTNode *Search(BTNode *bt,Int x) //在二叉排序樹 bt 查找的值為 x 結點 { if (bt==NULL) return NULL; if (x==bt->data) return bt; if (x<bt->data) return Search(bt->lchild,x); else return Search(bt->rchild,x); } void main() { BTNode *bt; Int a[]={4,3,2,8,6,7,9}; Int b[]={2,3,4,6,7,8,9}; int n=sizeof(a)/sizeof(a[0]); bt=CreateBTree(a,b,n); //構造一棵二叉排序樹 bt printf("二叉排序樹 bt:"); DispBTree(bt); printf("\n"); int x=6; BTNode *p=Search(bt,x); if (p!=NULL) printf("找到結點: %d\n",p->data); else printf("沒有找到結點\n",x); DestroyBTree(bt); //銷毀樹 bt } 上述程序的執行結果如圖 1.25 所示。 圖 1.25 程序執行結果 Search(bt，x)算法采用的是減治法，最好的情況是某個結點左右子樹高度大致相同， 其平均執行時間 T(n)如下： T(n)=1 當 n=1 T(n)=T(n/2)+1 當 n>1 可以推出 T(n)=O(log2n)，其中 n 為二叉排序樹的結點個數。 15. 解：采用二分查找方法。a[i]=i 時表示該元素在有序非重復序列 a 中恰好第 i 大。對於序列 a[low..high]，mid=(low+high)/2，若 a[mid]=mid 表示找到該元素；若 a[mid]>mid 說明右區間的所有元素都大於其位置，只能在左區間中查找；若 a[mid]<mid 說明左區間的所有元素都小於其位置，只能在右區間中查找。對應的程序如下： #include <stdio.h> int Search(int a[],int n) //查找使得 a[i]=i { int low=0,high=n-1,mid; while (low<=high) { mid=(low+high)/2; if (a[mid]==mid) //查找到這樣的元素 return mid; else if (a[mid]<mid) //這樣的元素只能在右區間中出現 low=mid+1; else //這樣的元素只能在左區間中出現 high=mid-1; } return -1; } void main() { int a[]={-2,-1,2,4,6,8,9}; int n=sizeof(a)/sizeof(a[0]); int i=Search(a,n); printf("求解結果\n"); if (i!=-1) printf(" 存在a[%d]=%d\n",i,i); else printf(" 不存在\n"); } 上述程序的執行結果如圖 1.26 所示。 圖 1.26 程序執行結果 16. 解：對於有序序列 a[low..high]，若元素個數少於 3 個，直接查找。若含有更多的元素，將其分為 a[low..mid1-1]、a[mid1+1..mid2-1]、a[mid2+1..high]子序列，對每個子序列遞歸查找，算法的時間復雜度為 O(log3n)，屬於 O(log2n)級別。對應的算法如下： #include <stdio.h> int Search(int a[],int low,int high,int x) //三分查找 return -1; } int length=(high-low+1)/3; //每個子序列的長度 int mid1=low+length; int mid2=high-length; if (x==a[mid1]) return mid1; else if (x<a[mid1]) return Search(a,low,mid1-1,x); else if (x==a[mid2]) return mid2; else if (x<a[mid2]) return Search(a,mid1+1,mid2-1,x); else return Search(a,mid2+1,high,x); } void main() { int a[]={1,3,5,7,9,11,13,15}; int n=sizeof(a)/sizeof(a[0]); printf("求解結果\n"); int x=13; int i=Search(a,0,n-1,x); if (i!=-1) printf(" a[%d]=%d\n",i,x); else printf(" 不存在%d\n",x); int y=10; int j=Search(a,0,n-1,y); if (j!=-1) printf(" a[%d]=%d\n",j,y); else printf(" 不存在%d\n",y); } 上述程序的執行結果如圖 1.27 所示。 圖 1.27 程序執行結果 17. 解：設 f(n)表示 n 的不同分解式個數。有： f(1)=1，作為遞歸出口 f(2)=1，分解式為：2=2 f(3)=1， 分 解 式 為 ：3=3 f(4)=2，分解式為：4=4，4=2*2 f(6)=3，分解式為：6=6，6=2*3，6=3*2，即 f(6)=f(1)+f(2)+f(3) 以此類推，可以看出 f(n)為 n 的所有因數的不同分解式個數之和，即 f(n)= ∑ 𝑓(𝑛/𝑖)。對應的程序如下： #include <stdio.h> #define MAX 101 int solve(int n) //求 n 的不同分解式個數 { if (n==1) return 1; else { int sum=0; for (int i=2;i<=n;i++) if (n%i==0) sum+=solve(n/i); return sum; } } void main() { int n=12; int ans=solve(n); printf("結果: %d\n",ans); } 上述程序的執行結果如圖 1.28 所示。 圖 1.28 程序執行結果 18. 解：對應的並行算法如下： int Sum(int a[],int s,int t,int p,int i) //處理器i執行求和 { int j,s=0; for (j=s;j<=t;j++) s+=a[j]; return s; } int ParaSum(int a[],int s,int t,int p,int i) { int sum=0,j,k=0,sj; for (j=0;j<p;j++) //for循環的各個子問題並行執行 { sj=Sum(a,k,k+n/p-1,p,j); k+=n/p; } sum+=sj; return sum; } 每個處理器的執行時間為O(n/p)，同步開銷為O(p)，所以該算法的時間復雜度為 O(n/p+p)。 1.4 第 4 章─蠻力法 1.4.1 練習題 1. 簡要比較蠻力法和分治法。 2. 在采用蠻力法求解時什么情況下使用遞歸？ 3. 考慮下面這個算法，它求的是數組 a 中大小相差最小的兩個元素的差。請對這個算法做盡可能多的改進。 #define INF 99999 #define abs(x) (x)<0?-(x):(x) //求絕對值宏 int Mindif(int a[],int n) { int dmin=INF; for (int i=0;i<=n-2;i++) for (int j=i+1;j<=n-1;j++) { int temp=abs(a[i]-a[j]); if (temp<dmin) dmin=temp; } return dmin; } 4. 給定一個整數數組 A=(a0，a1，…an-1)，若 i<j 且 ai>aj，則<ai，aj>就為一個逆序對。例如數組（3，1，4，5，2）的逆序對有<3，1>，<3，2>，<4，2>，<5，2>。設計一個算法采用蠻力法求 A 中逆序對的個數即逆序數。 5. 對於給定的正整數 n（n>1）, 采用蠻力法求 1!+2!+…+n!，並改進該算法提高效率。 6. 有一群雞和一群兔，它們的只數相同，它們的腳數都是三位數，且這兩個三位數的各位數字只能是 0、1、2、3、4、5。設計一個算法用蠻力法求雞和兔的只數各是多 少？它們的腳數各是多少？ 7. 有一個三位數，個位數字比百位數字大，而百位數字又比十位數字大，並且各位數字之和等於各位數字相乘之積，設計一個算法用窮舉法求此三位數。 8. 某年級的同學集體去公園划船，如果每只船坐 10 人，那么多出 2 個座位；如果每只船多坐 2 人，那么可少租 1 只船，設計一個算法用蠻力法求該年級的最多人數？ 9. 已知：若一個合數的質因數分解式逐位相加之和等於其本身逐位相加之和，則稱這 個 數 為 Smith 數 。 如 4937775=3*5*5*65837， 而 3+5+5+6+5+8+3+7=42， 4+9+3+7+7+7+5=42，所以 4937775 是 Smith 數。求給定一個正整數 N，求大於 N 的最小Smith 數。 輸入：若干個 case，每個 case 一行代表正整數 N，輸入 0 表示結束輸出：大於 N 的最小 Smith 數 輸入樣例： 4937774 0 樣例輸出： 4937775 10. 求解塗棋盤問題。小易有一塊 n*n 的棋盤，棋盤的每一個格子都為黑色或者白色，小易現在要用他喜歡的紅色去塗畫棋盤。小易會找出棋盤中某一列中擁有相同顏色的最大的區域去塗畫，幫助小易算算他會塗畫多少個棋格。 輸入描述：輸入數據包括 n+1 行：第一行為一個整數 n（1≤ n≤50），即棋盤的大小，接下來的 n 行每行一個字符串表示第 i 行棋盤的顏色，'W'表示白色，'B'表示黑色。 輸出描述：輸出小易會塗畫的區域大小。輸入例子： 3 BWW BBB BWB 輸出例子： 3 11. 給定一個含 n（n>1）個整數元素的 a，所有元素不相同，采用蠻力法求出 a 中所有元素的全排列。 1.4.2 練習題參考答案 1. 答：蠻力法是一種簡單直接地解決問題的方法，適用范圍廣，是能解決幾乎所有問題的一般性方法，常用於一些非常基本、但又十分重要的算法（排序、查找、矩陣乘法和字符串匹配等），蠻力法主要解決一些規模小或價值低的問題，可以作為同樣問題的更高效算法的一個標准。而分治法采用分而治之思路，把一個復雜的問題分成兩個或更多的相同或相似的子問題，再把子問題分成更小的子問題直到問題解決。分治法在求解問題 時，通常性能比蠻力法好。 2. 答：如果用蠻力法求解的問題可以分解為若干個規模較小的相似子問題，此時可以采用遞歸來實現算法。 3. 解：上述算法的時間復雜度為 O(n2)，采用的是最基本的蠻力法。可以先對 a 中元素遞增排序，然后依次比較相鄰元素的差，求出最小差，改進后的算法如下： #include <stdio.h> #include <algorithm> using namespace std; int Mindif1(int a[],int n) { sort(a,a+n); //遞增排序 int dmin=a[1]-a[0]; for (int i=2;i<n;i++) { int temp=a[i]-a[i-1]; if (temp<dmin) dmin=temp; } return dmin; } 上述算法的主要時間花費在排序上，算法的時間復雜度為 O(nlog2n)。 4. 解：采用兩重循環直接判斷是否為逆序對，算法的時間復雜度為 O(n2)，比第 3 章實驗 3 算法的性能差。對應的算法如下： int solve(int a[],int n) //求逆序數 { int ans=0; for (int i=0;i<n-1;i++) for (int j=i+1;j<n;j++) if (a[i]>a[j]) ans++; return ans; } 5. 解：直接采用蠻力法求解算法如下： long f(int n) //求n! { long fn=1; for (int i=2;i<=n;i++) fn=fn*i; return fn; } long solve(int n) //求1!+2!+…+n! { long ans=0; for (int i=1;i<=n;i++) ans+=f(i); return ans; } 實際上，f(n)=f(n-1)*n，f(1)=1，在求 f(n)時可以利用 f(n-1)的結果。改進后的算法如 下： long solve1(int n) //求1!+2!+…+n! { long ans=0; long fn=1; for (int i=1;i<=n;i++) { fn=fn*i; ans+=fn; } return ans; } 6. 解：設雞腳數為 y=abc，兔腳數為 z=def，有 1≤a，d≤5，0≤b，c，e，f≤5，采 用 6 重循環，求出雞只數 x1=y/2（y 是 2 的倍數），兔只數 x2=z/4（z 是 4 的倍數），當 x1=x2 時輸出結果。對應的程序如下： #include <stdio.h> void solve() { int a,b,c,d,e,f; int x1,x2,y,z; for (a=1;a<=5;a++) for (b=0;b<=5;b++) for (c=0;c<=5;c++) for (d=1;d<=5;d++) for (e=0;e<=5;e++) for (f=0;f<=5;f++) { y=a*100+b*10+c; //雞腳數 z=d*100+e*10+f; //兔腳數 if (y%2!=0 || z%4!=0) continue; x1=y/2; //雞只數 x2=z/4; //兔只數 if (x1==x2) printf(" 雞只數:%d,兔只數:%d,雞腳數:%d, 兔腳數:%d\n",x1,x2,y,z); } } void main() { printf("求解結果\n"); solve(); } 上述程序的執行結果如圖 1.29 所示。 圖 1.29 程序執行結果 7. 解：設該三位數為 x=abc，有 1≤a≤9，0≤b，c≤9，滿足 c>a，a>b， a+b+c=a*b*c。對應的程序如下： #include <stdio.h> void solve() { int a,b,c; for (a=1;a<=9;a++) for (b=0;b<=9;b++) for (c=0;c<=9;c++) { if (c>a && a>b && a+b+c==a*b*c) printf(" %d%d%d\n",a,b,c); } } void main() { printf("求解結果\n"); solve(); } 上述程序的執行結果如圖 1.30 所示。 圖 1.30 程序執行結果 8. 解：設該年級的人數為 x，租船數為 y。因為每只船坐 10 人正好多出 2 個座位，則x=10*y-2；因為每只船多坐 2 人即 12 人時可少租 1 只船（沒有說恰好全部座位占滿），有 x+z=12*(y-1)，z 表示此時空出的座位，顯然 z<12。讓 y 從 1 到 100（實際上 y 取更大范圍的結果是相同的）、z 從 0 到 11 枚舉，求出最大的 x 即可。對應的程序如下： #include <stdio.h> int solve() { int x,y,z; for (y=1;y<=100;y++) for (z=0;z<12;z++) if (10*y-2==12*(y-1)-z) x=10*y-2; return x; } void main() { printf("求解結果\n"); printf(" 最多人數:%d\n",solve()); } 上述程序的執行結果如圖 1.31 所示。 圖 1.31 程序執行結果 9. 解：采用蠻力法求出一個正整數 n 的各位數字和 sum1，以及 n 的所有質因數的數字和 sum2，若 sum1=sum2，即為 Smitch 數。從用戶輸入的 n 開始枚舉，若是 Smitch 數，輸出，本次結束，否則 n++繼續查找大於 n 的最小 Smitch 數。對應的完整程序如下： #include <stdio.h> int Sum(int n) //求n的各位數字和 { int sum=0; while (n>0) { sum+=n%10; n=n/10; } return sum; } bool solve(int n) //判斷n是否為Smitch數 { int m=2; int sum1=Sum(n); int sum2=0; while (n>=m) { if (n%m==0) //找到一個質因數m { n=n/m; sum2+=Sum(m); } else m++; } if (sum1==sum2) return true; else return false; } void main() { int n; while (true) { scanf("%d",&n); if (n==0) break; while (!solve(n)) n++; printf("%d\n",n); } } 10. 解：采用蠻力法，統計每一列相鄰相同顏色的棋格個數 countj，在 countj 中求最大值。對應的程序如下： #include <stdio.h> #define MAXN 51 //問題表示int n; char board[MAXN][MAXN]; int getMaxArea() //蠻力法求解算法 { int maxArea=0; for (int j=0; j<n; j++) { int countj=1; for (int i=1; i<n; i++) //統計第j列中相同顏色相鄰棋格個數 { if (board[i][j]==board[i-1][j]) countj++; else countj=1; } if (countj>maxArea) maxArea=countj; } return maxArea; } int main() { scanf("%d",&n); for (int i=0;i<n;i++) scanf("%s",board[i]); printf("%d\n",getMaxArea()); return 0; } 11. 解：與《教程》中求全排列類似，但需要將求 1～n 的全排列改為按下標 0～n-1 求 a 的全排列（下標從 0 開始）。采用非遞歸的程序如下： #include <stdio.h> #include <vector> using namespace std; vector<vector<int> > ps; //存放全排列 void Insert(vector<int> s,int a[],int i,vector<vector<int> > &ps1) //在每個集合元素中間插入i得到ps1 { vector<int> s1; vector<int>::iterator it; for (int j=0;j<=i;j++) //在s(含i個整數)的每個位置插入a[i] { s1=s; it=s1.begin()+j; //求出插入位置 s1.insert(it,a[i]); //插入整數a[i] ps1.push_back(s1); //添加到ps1中 } } void Perm(int a[],int n) //求a[0..n-1]的所有全排列 { vector<vector<int> > ps1; //臨時存放子排列 vector<vector<int> >::iterator it; //全排列迭代器 vector<int> s,s1; s.push_back(a[0]); ps.push_back(s); //添加{a[0]}集合元素 for (int i=1;i<n;i++) //循環添加a[1]～a[n-1] { ps1.clear(); //ps1存放插入a[i]的結果 for (it=ps.begin();it!=ps.end();++it) Insert(*it,a,i,ps1); //在每個集合元素中間插入a[i]得到ps1 ps=ps1; } } void dispps() //輸出全排列 ps { vector<vector<int> >::reverse_iterator it; //全排列的反向迭代器 vector<int>::iterator sit; //排列集合元素迭代器 for (it=ps.rbegin();it!=ps.rend();++it) { for (sit=(*it).begin();sit!=(*it).end();++sit) printf("%d",*sit); printf(" "); } printf("\n"); } void main() { int a[]={2,5,8}; int n=sizeof(a)/sizeof(a[0]); printf("a[0～%d]的全排序如下:\n ",n-1); Perm(a,n); dispps(); } 上述程序的執行結果如圖 1.32 所示。 圖 1.32 程序執行結果 1.5 第 5 章─回溯法 1.5.1 練習題 1. 回溯法在問題的解空間樹中，按（ ）策略，從根結點出發搜索解空間樹。 A. 廣度優先 B.活結點優先 C.擴展結點優先 D.深度優先 2. 關於回溯法以下敘述中不正確的是（ ）。 A.回溯法有“通用解題法”之稱，它可以系統地搜索一個問題的所有解或任意解 B.回溯法是一種既帶系統性又帶有跳躍性的搜索算法 C.回溯算法需要借助隊列這種結構來保存從根結點到當前擴展結點的路徑 D.回溯算法在生成解空間的任一結點時，先判斷該結點是否可能包含問題的解，如果肯定不包含，則跳過對該結點為根的子樹的搜索，逐層向祖先結點回溯 3. 回溯法的效率不依賴於下列哪些因素（ ）。 A. 確定解空間的時間 B.滿足顯約束的值的個數 C.計算約束函數的時間 D.計算限界函數的時間 4. 下面（ ）函數是回溯法中為避免無效搜索采取的策略。 A.遞歸函數 B.剪枝函數 C.隨機數函數 D.搜索函數5.回溯法的搜索特點是什么？ 6. 用回溯法解 0/1 背包問題時，該問題的解空間是何種結構？用回溯法解流水作業調度問題時，該問題的解空間是何種結構？ 7. 對於遞增序列 a[]={1，2，3，4，5}，采用例 5.4 的回溯法求全排列，以 1、2 開頭的排列一定最先出現嗎？為什么？ 8. 考慮 n 皇后問題，其解空間樹為由 1、2、…、n 構成的 n!種排列所組成。現用回 溯法求解，要求： （1） 通過解搜索空間說明 n=3 時是無解的。 （2） 給出剪枝操作。 （3） 最壞情況下在解空間樹上會生成多少個結點？分析算法的時間復雜度。 9. 設計一個算法求解簡單裝載問題，設有一批集裝箱要裝上一艘載重量為 W 的輪船，其中編號為 i（0≤i≤n-1）的集裝箱的重量為 wi。現要從 n 個集裝箱中選出若干裝上輪船，使它們的重量之和正好為 W。如果找到任一種解返回 true，否則返回 false。 10. 給定若干個正整數a0、a0 、…、an-1 ，從中選出若干數，使它們的和恰好為k， 要求找選擇元素個數最少的解。 11. 設計求解有重復元素的排列問題的算法，設有 n 個元素 a[]={a0，a1，…，an-1)， 其中可能含有重復的元素，求這些元素的所有不同排列。如 a[]={1，1，2}，輸出結果是 （1，1，2)，（1，2，1），（2，1，1）。 12. 采用遞歸回溯法設計一個算法求1～n的n個整數中取出m個元素的排列，要求每個元素最多只能取一次。例如，n=3，m=2的輸出結果是（1，2），（1，3），（2，1）， （2，3），（3，1），（3，2）。 13. 對於n皇后問題，有人認為當n為偶數時，其解具有對稱性，即n皇后問題的解個數恰好為n/2皇后問題的解個數的2倍，這個結論正確嗎？請編寫回溯法程序對n=4、6、 8、10的情況進行驗證。 14. 給定一個無向圖，由指定的起點前往指定的終點，途中經過所有其他頂點且只經過一次，稱為哈密頓路徑，閉合的哈密頓路徑稱作哈密頓回路（Hamiltonian cycle）。設計一個回溯算法求無向圖的所有哈密頓回路。 1.5.2 練習題參考答案 1. 答：D。 2. 答：回溯算法是采用深度優先遍歷的，需要借助系統棧結構來保存從根結點到當前擴展結點的路徑。答案為 C。 3. 答：回溯法解空間是虛擬的，不必確定整個解空間。答案為 A。 4. 答：B。 5. 答：回溯法在解空間樹中采用深度優先遍歷方式進行解搜索，即用約束條件和限界函數考察解向量元素 x[i]的取值，如果 x[i]是合理的就搜索 x[i]為根結點的子樹，如果x[i]取完了所有的值，便回溯到 x[i-1]。 6. 答：用回溯法解 0/1 背包問題時，該問題的解空間是子集樹結構。用回溯法解流水作業調度問題時，該問題的解空間是排列樹結構。 7. 答：是的。對應的解空間是一棵排列樹，如圖 1.33 所示給出前面 3 層部分，顯然最先產生的排列是從 G 結點擴展出來的葉子結點，它們就是以 1、2 開頭的排列。 圖 1.33 部分解空間樹 8. 答：（1）n=3 時的解搜索空間如圖 1.34 所示，不能得到任何葉子結點，所有無解。 （2） 剪枝操作是任何兩個皇后不能同行、同列和同兩條對角線。 （3） 最壞情況下每個結點擴展 n 個結點，共有 nn 個結點，算法的時間復雜度為 O(nn)。 圖 1.34 3 皇后問題的解搜索空間 9. 解：用數組 w[0..n-1]存放 n 個集裝箱的重量，采用類似判斷子集和是否存在解的方法求解。對應完整的求解程序如下： #include <stdio.h> #define MAXN 20 //最多集裝箱個數 //問題表示 int n=5,W; int w[]={2,9,5,6,3}; int count; //全局變量，累計解個數 void dfs(int tw,int rw,int i) //求解簡單裝載問題 { if (i>=n) //找到一個葉子結點 bool solve() //判斷簡單裝載問題是否存在解 { count=0; int rw=0; for (int j=0;j<n;j++) rw+=w[j]; //求所有集裝箱重量和rw dfs(0,rw,0); //i從0開始 if (count>0) return true; else return false; } void main() { printf("求解結果\n"); W=4; printf(" W=%d時%s\n",W,(solve()?"存在解":"沒有解")); W=10; printf(" W=%d時%s\n",W,(solve()?"存在解":"沒有解")); W=12; printf(" W=%d時%s\n",W,(solve()?"存在解":"沒有解")); W=21; printf(" W=%d時%s\n",W,(solve()?"存在解":"沒有解")); } 本程序執行結果如圖 1.35 所示。 圖 1.35 程序執行結果 10. 解：這是一個典型的解空間為子集樹的問題，采用子集樹的回溯算法框架。當找到一個解后通過選取的元素個數進行比較求最優解 minpath。對應的完整程序如下： #include <stdio.h> #include <vector> using namespace std; //問題表示 int a[]={1,2,3,4,5}; //設置為全局變量 int n=5,k=9; vector<int> minpath; //存放最優解 //求解結果表示 int minn=n; //最多選擇n個元素 void disppath() //輸出一個解 { printf(" 選擇的元素:"); for (int j=0;j<minpath.size();j++) printf("%d ",minpath[j]); printf("元素個數=%d\n",minn); } void dfs(vector<int> path,int sum,int start) //求解算法 { if (sum==k) //如果找到一個解，不一定到葉子結點 { if (path.size()<minn) { minn=path.size(); minpath=path; } return; } if (start>=n) return; //全部元素找完，返回 dfs(path,sum,start+1); //不選擇a[start] path.push_back(a[start]); //選擇a[start] dfs(path,sum+a[start],start+1); } void main() { vector<int> path; //path存放一個子集 dfs(path,0,0); printf("最優解:\n"); disppath(); } 上述程序的執行結果如圖 1.36 所示。 圖 1.36 程序執行結果 11. 解：在回溯法求全排列的基礎上，增加元素的重復性判斷。例如，對於 a[]={1， 1，2}，不判斷重復性時輸出（1，1，2），（1，2，1），（1，1，2），（1，2，1）， （2，1，1），（2，1，1），共 6 個，有 3 個是重復的。重復性判斷是這樣的，對於在擴展 a[i]時，僅僅將與 a[i..j-1]沒有出現的元素 a[j]交換到 a[i]的位置，如果出現，對應的排列已經在前面求出了。對應的完整程序如下： #include <stdio.h> bool ok(int a[],int i,int j) //ok用於判別重復元素 { if (j>i) { for(int k=i;k<j;k++) if (a[k]==a[j]) return false; } return true; } void swap(int &x,int &y) //交換兩個元素 { int tmp=x; x=y; y=tmp; } void dfs(int a[],int n,int i) //求有重復元素的排列問題 { if (i==n) { } for(int j=0;j<n;j++) printf("%3d",a[j]); printf("\n"); else { for (int j=i;j<n;j++) if (ok(a,i,j)) //選取與a[i..j-1]不重復的元素a[j] { swap(a[i],a[j]); dfs(a,n,i+1); swap(a[i],a[j]); } } } void main() { int a[]={1,2,1,2}; int n=sizeof(a)/sizeof(a[0]); printf("序列("); for (int i=0;i<n-1;i++) printf("%d ",a[i]); printf("%d)的所有不同排列:\n",a[n-1]); dfs(a,n,0); } 上述程序的執行結果如圖 1.37 所示。 圖 1.37 程序執行結果 12. 解：采用求全排列的遞歸框架。選取的元素個數用 i 表示（i 從 1 開始），當 i>m時達到一個葉子結點，輸出一個排列。為了避免重復，用 used 數組實現，used[i]=0 表示沒有選擇整數 i，used[i]=1 表示已經選擇整數 i。對應的完整程序如下： #include <stdio.h> #include <string.h> #define MAXN 20 #define MAXM 10 int m,n; } else { for (int j=1;j<=n;j++) { if (!used[j]) { used[j]=true; //修改used[i] x[i]=j; //x[i]選擇j dfs(i+1); //繼續搜索排列的下一個元素 } } } } used[j]=false; //回溯：恢復used[i] voi { d main() n=4,m=2; memset(used,0,sizeof(used)); //初始化為0 printf("n=%d,m=%d的求解結果\n",n,m); dfs(1); //i從1開始 } 上述程序的執行結果如圖 1.38 所示。 圖 1.38 程序執行結果 13. 解：這個結論不正確。驗證程序如下： #include <stdio.h> #include <stdlib.h> #define MAXN 10 int q[MAXN]; bool place(int i) //測試第i行的q[i]列上能否擺放皇后 { int j=1; if (i==1) return true; while (j<i) //j=1～i-1是已放置了皇后的行 { if ((q[j]==q[i]) || (abs(q[j]-q[i])==abs(j-i))) //該皇后是否與以前皇后同列，位置(j,q[j])與(i,q[i])是否同對角線 return false; j++; } return true; } int Queens(int n) //求n皇后問題的解個數 { int count=0,k; //計數器初始化 int i=1; //i為當前行 q[1]=0; //q[i]為皇后i的列號 while (i>0) { q[i]++; //移到下一列 while (q[i]<=n && !place(i)) q[i]++; if (q[i]<=n) { if (i==n) count++; //找到一個解計數器count加1 else { i++;; q[i]=0; } } else i--; //回溯 } return count; } void main() { printf("驗證結果如下:\n"); for (int n=4;n<=10;n+=2) if (Queens(n)==2*Queens(n/2)) printf(" n=%d: 正確\n",n); else printf(" n=%d: 錯誤\n",n); } 上述程序的執行結果如圖1.39所示。從執行結果看出結論是不正確的。 圖 1.39 程序執行結果 14. 解：假設給定的無向圖有 n 個頂點（頂點編號從 0 到 n-1），采用鄰接矩陣數組 a （0/1 矩陣）存放，求從頂點 v 出發回到頂點 v 的哈密頓回路。采用回溯法，解向量為x[0..n]，x[i]表示第 i 步找到的頂點編號（i=n-1 時表示除了起點 v 外其他頂點都查找了），初始時將起點 v 存放到 x[0]，i 從 1 開始查找，i>0 時循環：為 x[i]找到一個合適的頂點， 當 i=n-1 時，若頂點 x[i]到頂點 v 有邊對應一個解；否則繼續查找下一個頂點。如果不能為 x[i]找到一個合適的頂點，則回溯。采用非遞歸回溯框架（與《教程》中求解 n 皇后問題的非遞歸回溯框架類似）的完整程序如下： #include <stdio.h> #define MAXV 10 //求解問題表示 int n=5; //圖中頂點個數 int a[MAXV][MAXV]={{0,1,1,1,0},{1,0,0,1,1},{1,0,0,0,1},{1,1,0,0,1},{0,1,1,1,0}}; //鄰接矩陣數組 //求解結果表示int x[MAXV]; int count; void dispasolution() //輸出一個解路徑 { for (int i=0;i<=n-1;i++) printf("(%d,%d) ",x[i],x[i+1]); printf("\n"); } bool valid(int i) //判斷頂點第i個頂點x[i]的有效性 { if (a[x[i-1]][x[i]]!=1) //x[i-1]到x[i]沒有邊，返回false return false; for (int j=0;j<=i-1;j++) if (x[i]==x[j]) //頂點i重復出現，返回false return false; return true; } void Hamiltonian(int v) //求從頂點v出發的哈密頓回路 { x[0]=v; //存放起點 int i=1; x[i]=-1; //從頂點-1+1=0開始試探 while (i>0) //尚未回溯到頭，循環 { x[i]++; while (!valid(i) && x[i]<n) x[i]++; //試探一個頂點x[i] if (x[i]<n) //找到一個有效的頂點x[i] { if (i==n-1) //達到葉子結點 { if (a[x[i]][v]==1) { x[n]=v; //找到一個解 printf(" 第%d個解: ",count++); dispasolution(); } } else { i++; x[i]=-1; } } else i--; //回溯 } } void main() { printf("求解結果\n"); for (int v=0;v<n;v++) { printf(" 從頂點%d出發的哈密頓回路:\n",v); count=1; Hamiltonian(v); //從頂點v出發 } } 上述程序對如圖 1.40 所示的無向圖求從每個頂點出發的哈密頓回路，程序執行結果如圖 1.41 所示。 圖 1.40 一個無向圖 圖 1.41 程序執行結果 1.6 第 6 章─分枝限界法 1.6.1 練習題 1. 分枝限界法在問題的解空間樹中，按（ ）策略，從根結點出發搜索解空間樹。 A. 廣度優先 B.活結點優先 C.擴展結點優先 D. 深度優先 2. 常見的兩種分枝限界法為（ ）。 A. 廣度優先分枝限界法與深度優先分枝限界法 B. 隊列式（FIFO）分枝限界法與堆棧式分枝限界法C.排列樹法與子集樹法 D.隊列式（FIFO）分枝限界法與優先隊列式分枝限界法 3. 分枝限界法求解 0/1 背包問題時，活結點表的組織形式是（ ）。A.小根堆 B.大根堆 C.棧 D.數組 4. 采用最大效益優先搜索方式的算法是（ ）。 A. 分支界限法 B.動態規划法 C.貪心法 D.回溯法 5. 優先隊列式分枝限界法選取擴展結點的原則是（ ）。 A. 先進先出 B.后進先出 C.結點的優先級 D.隨機 6. 簡述分枝限界法的搜索策略。 7. 有一個 0/1 背包問題，其中 n=4，物品重量為（4，7，5，3），物品價值為（40， 42，25，12），背包最大載重量 W=10，給出采用優先隊列式分枝限界法求最優解的過程。 8. 有一個流水作業調度問題，n=4，a[]={5，10，9，7}，b[]={7，5，9，8}，給出采用優先隊列式分枝限界法求一個解的過程。 9. 有一個含 n 個頂點（頂點編號為 0～n-1）的帶權圖，采用鄰接矩陣數組 A 表示， 采用分枝限界法求從起點 s 到目標點 t 的最短路徑長度，以及具有最短路徑長度的路徑條數。 10. 采用優先隊列式分枝限界法求解最優裝載問題。給出以下裝載問題的求解過程和結果：n=5，集裝箱重量為 w=（5，2，6，4，3），限重為 W=10。在裝載重量相同時，最優裝載方案是集裝箱個數最少的方案。 1.6.2 練習題參考答案 1. 答：A。 2. 答：D。 3. 答：B。 4. 答：A。 5. 答：C。 6. 答：分枝限界法的搜索策略是廣度優先遍歷，通過限界函數可以快速找到一個解或者最優解。 7. 答：求解過程如下： （1）根結點 1 進隊，對應結點值：e.i=0，e.w=0，e.v=0，e.ub=76，x:[0，0，0，0]。 （2） 出隊結點 1：左孩子結點 2 進隊，對應結點值：e.no=2，e.i=1，e.w=4， e.v=40，e.ub=76，x:[1，0，0，0]；右孩子結點 3 進隊，對應結點值：e.no=3，e.i=1， e.w=0，e.v=0，e.ub=57，x:[0，0，0，0]。 （3） 出隊結點 2：左孩子超重；右孩子結點 4 進隊，對應結點值：e.no=4，e.i=2， e.w=4，e.v=40，e.ub=69，x:[1，0，0，0]。 （4） 出隊結點 4：左孩子結點 5 進隊，對應結點值：e.no=5，e.i=3，e.w=9， e.v=65，e.ub=69，x:[1，0，1，0]；右孩子結點 6 進隊，對應結點值：e.no=6，e.i=3， e.w=4，e.v=40，e.ub=52，x:[1，0，0，0]。 （5） 出隊結點 5：產生一個解，maxv= 65，bestx:[1，0，1，0]。 （6） 出隊結點 3：左孩子結點 8 進隊，對應結點值：e.no=8，e.i=2，e.w=7， e.v=42，e.ub=57，x:[0，1，0，0]；右孩子結點 9 被剪枝。 （7） 出隊結點 8：左孩子超重；右孩子結點 10 被剪枝。 （8） 出隊結點 6：左孩子結點 11 超重；右孩子結點 12 被剪枝。 （9） 隊列空，算法結束，產生的最優解：maxv= 65，bestx:[1，0，1，0]。 8. 答：求解過程如下： （1）根結點 1 進隊，對應結點值：e.i=0，e.f1=0，e.f2=0，e.lb=29， x：[0，0，0， 0]。 （2） 出隊結點 1：擴展結點如下： 進隊（j=1）：結點 2，e.i=1，e.f1=5，e.f2=12，e.lb=27，x：[1，0，0，0]。進隊（j=2）：結點 3，e.i=1，e.f1=10，e.f2=15，e.lb=34，x：[2，0，0，0]。進隊（j=3）：結點 4，e.i=1，e.f1=9，e.f2=18，e.lb=29，x：[3，0，0，0]。進隊（j=4）：結點 5，e.i=1，e.f1=7，e.f2=15，e.lb=28，x：[4，0，0，0]。 （3） 出隊結點 2：擴展結點如下： 進隊（j=2）：結點 6，e.i=2，e.f1=15，e.f2=20，e.lb=32，x：[1，2，0，0]。進隊（j=3）：結點 7，e.i=2，e.f1=14，e.f2=23，e.lb=27，x：[1，3，0，0]。進隊（j=4）：結點 8，e.i=2，e.f1=12，e.f2=20，e.lb=26，x：[1，4，0，0]。 （4） 出隊結點 8：擴展結點如下： 進隊（j=2）：結點 9，e.i=3，e.f1=22，e.f2=27，e.lb=31，x：[1，4，2，0]。進隊（j=3）：結點 10，e.i=3，e.f1=21，e.f2=30，e.lb=26，x：[1，4，3，0]。 （5） 出隊結點 10，擴展一個 j=2 的子結點，有 e.i=4，到達葉子結點，產生的一個解 是 e.f1=31，e.f2=36，e.lb=31，x=[1，4，3，2]。 該解對應的調度方案是：第 1 步執行作業 1，第 2 步執行作業 4，第 3 步執行作業3，第 4 步執行作業 2，總時間=36。 9. 解：采用優先隊列式分枝限界法求解，隊列中結點的類型如下： struct NodeType { int vno; //頂點的編號 int length; //當前結點的路徑長度 bool operator<(const NodeType &s) const //重載<關系函數 { return length>s.length; } //length越小越優先 }; 從頂點 s 開始廣度優先搜索，找到目標點 t 后比較求最短路徑長度及其路徑條數。對應的完整程序如下： #include <stdio.h> #include <queue> using namespace std; #define MAX 11 #define INF 0x3f3f3f3f //問題表示 int A[MAX][MAX]={ //一個帶權有向圖 {0，1，4，INF，INF}， {INF，0，INF，1，5}， {INF，INF，0，INF，1}， {INF，INF，2，0，3}， {INF，INF，INF，INF，INF} }; int n=5; //求解結果表示 int bestlen=INF; //最優路徑的路徑長度 int bestcount=0; //最優路徑的條數 struct NodeType { int vno; //頂點的編號 int length; //當前結點的路徑長度 bool operator<(const NodeType &s) const //重載>關系函數 { return length>s.length; } //length越小越優先 }; void solve(int s，int t) //求最短路徑問題 { NodeType e，e1; //定義2個結點 priority_queue<NodeType> qu; //定義一個優先隊列qu e.vno=s; //構造根結點 e.length=0; qu.push(e); //根結點進隊 while (!qu.empty()) //隊不空循環 { e=qu.top(); qu.pop(); //出隊結點e作為當前結點 if (e.vno==t) //e是一個葉子結點 { if (e.length<bestlen) //比較找最優解 { bestcount=1; bestlen=e.length; //保存最短路徑長度 } else if (e.length==bestlen) bestcount++; } else //e不是葉子結點 { for (int j=0; j<n; j++) //檢查e的所有相鄰頂點 if (A[e.vno][j]!=INF && A[e.vno][j]!=0) //頂點e.vno到頂點j有邊 { if (e.length+A[e.vno][j]<bestlen) //剪枝 { e1.vno=j; e1.length=e.length+A[e.vno][j]; qu.push(e1); //有效子結點e1進隊 } } } } } void main() { int s=0，t=4; solve(s，t); if (bestcount==0) printf("頂點%d到%d沒有路徑\n"，s，t); else { printf("頂點%d到%d存在路徑\n"，s，t); printf(" 最短路徑長度=%d，條數=%d\n"， bestlen，bestcount); //輸出：5 3 } } 上述程序的執行結果如圖 1.39 所示。 圖 1.39 程序執行結果 10. 解：采用優先隊列式分枝限界法求解。設計優先隊列priority_queue<NodeType>，並設計優先隊列的關系比較函數 Cmp，指定按結點的 ub 值進行比較，即 ub 值越大的結點越先出隊。對應的完整程序如下： #include <stdio.h> #include <queue> using namespace std; #define MAXN 21 //最多的集裝箱數 //問題表示 int n=5; int W=10; int w[]={0,5,2,6,4,3}; //集裝箱重量,不計下標0的元素 //求解結果表示 int bestw=0; //存放最大重量,全局變量 int bestx[MAXN]; //存放最優解,全局變量 int Count=1; //搜索空間中結點數累計,全局變量 typedef struct { int no; //結點編號 int i; //當前結點在解空間中的層次 int w; //當前結點的總重量 int x[MAXN]; //當前結點包含的解向量 int ub; //上界 } NodeType; struct Cmp //隊列中關系比較函數 { bool operator()(const NodeType &s,const NodeType &t) { return (s.ub<t.ub) || (s.ub==t.ub && s.x[0]>t.x[0]); //ub越大越優先,當ub相同時x[0]越小越優先 } }; } void Loading() //求裝載問題的最優解 { NodeType e,e1,e2; //定義3個結點 priority_queue<NodeType,vector<NodeType>,Cmp > qu; //定義一個優先隊列qu e.no=Count++; //設置結點編號 e.i=0; //根結點置初值,其層次計為0 e.w=0; for (int j=0; j<=n; j++) //初始化根結點的解向量 e.x[j]=0; bound(e); //求根結點的上界 qu.push(e); //根結點進隊 while (!qu.empty()) //隊不空循環 { e=qu.top(); qu.pop(); //出隊結點e作為當前結點 if (e.i==n) //e是一個葉子結點 { if ((e.w>bestw) || (e.w==bestw && e.x[0]<bestx[0])) //比較找最優解 { bestw=e.w; //更新bestw } for (int j=0;j<=e.i;j++) bestx[j]=e.x[j]; //復制解向量e.x->bestx } else //e不是葉子結點 { if (e.w+w[e.i+1]<=W) //檢查左孩子結點 { e1.no=Count++; //設置結點編號 e1.i=e.i+1; //建立左孩子結點 e1.w=e.w+w[e1.i]; for (int j=0; j<=e.i; j++) e1.x[j]=e.x[j]; //復制解向量e.x->e1.x e1.x[e1.i]=1; //選擇集裝箱i e1.x[0]++; //裝入集裝箱數增1 bound(e1); //求左孩子結點的上界 qu.push(e1); //左孩子結點進隊 } e2.no=Count++; //設置結點編號 e2.i=e.i+1; //建立右孩子結點 e2.w=e.w; for (int j=0; j<=e.i; j++) //復制解向量e.x->e2.x e2.x[j]=e.x[j]; e2.x[e2.i]=0; //不選擇集裝箱i bound(e2); //求右孩子結點的上界 if (e2.ub>bestw) //若右孩子結點可行,則進隊,否則被剪枝 qu.push(e2); } } } void disparr(int x[],int len) //輸出一個解向量 { for (int i=1;i<=len;i++) printf("%2d",x[i]); } void dispLoading() //輸出最優解 { printf(" X=["); disparr(bestx,n); printf("],裝入總價值為%d\n",bestw); } void main() { Loading(); printf("求解結果:\n"); dispLoading(); //輸出最優解 } 上述程序的執行結果如圖 1.40 所示。 圖 1.40 程序執行結果 1.7 第 7 章─貪心法 1.7.1 練習題 1. 下面是貪心算法的基本要素的是（ ）。 A. 重疊子問題 B.構造最優解 C.貪心選擇性質 D.定義最優解 2. 下面問題（ ）不能使用貪心法解決。 A. 單源最短路徑問題 B.n 皇后問題 C.最小花費生成樹問題 D.背包問題 3. 采用貪心算法的最優裝載問題的主要計算量在於將集裝箱依其重量從小到大排序，故算法的時間復雜度為（ ）。 A.O(n) B.O(n2) C.O(n3) D.O(nlog2n) 4. 關於 0/ 1 背包問題以下描述正確的是（ ）。A.可以使用貪心算法找到最優解 B. 能找到多項式時間的有效算法 C. 使用教材介紹的動態規划方法可求解任意 0－1 背包問題 D. 對於同一背包與相同的物品，做背包問題取得的總價值一定大於等於做 0/1 背包問 題 5. 一棵哈夫曼樹共有 215 個結點，對其進行哈夫曼編碼，共能得到（ ）個不同的碼 字。 A.107 B.108 C.214 D.215 6. 求解哈夫曼編碼中如何體現貪心思路？ 7. 舉反例證明 0/1 背包問題若使用的算法是按照 vi/wi 的非遞減次序考慮選擇的物品，即只要正在被考慮的物品裝得進就裝入背包，則此方法不一定能得到最優解（此題說明 0/1 背包問題與背包問題的不同）。 8. 求解硬幣問題。有 1 分、2 分、5 分、10 分、50 分和 100 分的硬幣各若干枚，現在要用這些硬幣來支付 W 元，最少需要多少枚硬幣。 9. 求解正整數的最大乘積分解問題。將正整數 n 分解為若干個互不相同的自然數之和，使這些自然數的乘積最大。 10. 求解乘船問題。有 n 個人，第 i 個人體重為 wi（0≤i<n）。每艘船的最大載重量均為 C，且最多只能乘兩個人。用最少的船裝載所有人。 11. 求解會議安排問題。有一組會議 A 和一組會議室 B，A[i]表示第 i 個會議的參加人數，B[j]表示第 j 個會議室最多可以容納的人數。當且僅當 A[i]≤B[j]時，第 j 個會議室可以用於舉辦第 i 個會議。給定數組 A 和數組 B，試問最多可以同時舉辦多少個會議。例如，A[]={1，2，3}，B[]={3，2，4}，結果為 3；若 A[]={3，4，3，1}，B[]={1，2，2， 6}，結果為 2. 12. 假設要在足夠多的會場里安排一批活動，n 個活動編號為 1～n，每個活動有開始時間 bi 和結束時間 ei（1≤i≤n）。設計一個有效的貪心算法求出最少的會場個數。 13. 給定一個 m×n 的數字矩陣，計算從左到右走過該矩陣且經過的方格中整數最小的路徑。一條路徑可以從第 1 列的任意位置出發，到達第 n 列的任意位置，每一步為從第 i 列走到第 i+1 列相鄰行（水平移動或沿 45 度斜線移動），如圖 1.41 所示。第 1 行和最后一行看作是相鄰的，即應當把這個矩陣看成是一個卷起來的圓筒。 圖 1.41 每一步的走向 兩個略有不同的 5×6 的數字矩陣的最小路徑如圖 1.42 所示，只有最下面一行的數不同。右邊矩陣的路徑利用了第一行與最后一行相鄰的性質。 輸入：包含多個矩陣，每個矩陣的第一行為兩個數 m 和 n，分別表示矩陣的行數和列數，接下來的 m×n 個整數按行優先的順序排列，即前 n 個數組成第一行，接下的 n 個數組成第 2 行，依此類推。相鄰整數間用一個或多個空格分隔。注意這些數不一定是正數。輸入中可能有一個或多個矩陣描述，直到輸入結束。每個矩陣的行數在 1 到 10 之間，列數在 1 到 100 之間。 輸出：對每個矩陣輸出兩行，第一行為最小整數之和的路徑，路徑由 n 個整數組成， 表示路徑經過的行號，如果這樣的路徑不止一條，輸出字典序最小一條。 3 4 1 2 8 6 圖 1.42 兩個數字矩陣的最小路徑 6 1 8 2 7 4 5 9 3 9 9 5 8 4 1 3 2 6 3 7 2 1 2 3 6 1 8 2 7 4 5 9 3 9 9 5 8 4 1 3 2 6 3 7 2 8 6 4 輸出結果： 1 2 3 4 4 5 16 1.7.2 練習題參考答案 1. 答：C。 2. 答：n 皇后問題的解不滿足貪心選擇性質。答案為 B。 3. 答：D。 4. 答：由於背包問題可以取物品的一部分，所以總價值一定大於等於做 0/1 背包問題。答案為 D。 5. 答：這里 n=215，哈夫曼樹中 n1=0，而 n0=n2+1，n=n0+n1+n2=2n0-1， n0=(n+1)/2=108。答案為 B。 6. 答：在構造哈夫曼樹時每次都是將兩棵根結點最小的樹合並，從而體現貪心的思路。 7. 證明：例如，n=3，w={3，2，2}，v={7，4，4}，W=4 時，由於 7/3 最大，若按題目要求的方法，只能取第一個，收益是 7。而此實例的最大的收益應該是 8，取第 2、3 個物品。 8. 解：用結構體數組 A 存放硬幣數據，A[i].v 存放硬幣 i 的面額，A[i].c 存放硬幣 i 的枚數。采用貪心思路，首先將數組 A 按面額遞減排序，再兌換硬幣，每次盡可能兌換面額大的硬幣。對應的完整程序如下： #include <stdio.h> #include <algorithm> using namespace std; #define min(x,y) ((x)<(y)?(x):(y)) #define MAX 21 //問題表示int n=7; struct NodeType { int v; //面額 int c; //枚數 bool operator<(const NodeType &s) { //用於按面額遞減排序 return s.v<v; } }; NodeType A[]={{1,12},{2,8},{5,6},{50,10},{10,8},{200,1},{100,4}}; int W; //求解結果表示 { sort(A,A+n); //按面額遞減排序 for (int i=0;i<n;i++) { int t=min(W/A[i].v,A[i].c); //使用硬幣i的枚數 if (t!=0) printf(" 支付%3d面額: %3d枚\n",A[i].v,t); W-=t*A[i].v; //剩余的金額 ans+=t; if (W==0) break; } } void main() { W=325; //支付的金額 printf("支付%d分:\n",W); solve(); printf("最少硬幣的個數: %d枚\n",ans); } 上述程序的執行結果如圖 1.43 所示。 圖 1.43 程序執行結果 9. 解：采用貪心方法求解。用 a[0..k]存放 n 的分解結果： （1） n≤4 時可以驗證其分解成幾個正整數的和的乘積均小於 n，沒有解。 （2） n>4 時，把 n 分拆成若干個互不相等的自然數的和，分解數的個數越多乘積越大。為此讓 n 的分解數個數盡可能多（體現貪心的思路），把 n 分解成從 2 開始的連續的自然數之和。例如，分解 n 為 a[0]=2，a[1]=3，a[2]=4，…，a[k]=k+2（共有 k+1 個分解數），用 m 表示剩下數，這樣的分解直到 m≤a[k]為止，即 m≤k+2。對剩下數 m 的處理分為如下兩種情況： ① m<k+2：將 m 平均分解到 a[k..i]（對應的分解數個數為 m）中，即從 a[k]開始往前的分解數增加 1（也是貪心的思路，分解數越大加 1 和乘積也越大）。 ② m=k+2：將 a[0..k-1] （對應的分解數個數為 k）的每個分解數增加 1，剩下的 2 增加到 a[k]中，即 a[k]增加 2。 對應的完整程序如下： #include <stdio.h> #include <string.h> #define MAX 20 //問題表示int n; //求解結果表示 int a[MAX]; int k=0; void solve() //存放被分解的數 //a[0..k]存放被分解的數 //求解n的最大乘積分解問題 { int i; int sum=1; if (n<4) //不存在最優方案,直接返回 return; else { int m=n; //m表示剩下數 a[0]=2; //第一個數從2開始 m-=a[0]; //減去已經分解的數 k=0; while (m>a[k]) //若剩下數大於最后一個分解數,則繼續分解 { k++; //a數組下標+1 a[k]=a[k-1]+1; //按2、3、4遞增順序分解 m-=a[k]; //減去最新分解的數 } if (m<a[k]) //若剩下數小於a[k],從a[k]開始往前的數+1 { for (i=0; i<m; i++) a[k-i]+=1; } if (m==a[k]) //若剩下數等於a[k],則a[k]的值+2,之前的數+1 { a[k]+=2; for (i=0; i<k; i++) a[i]+=1; } } } void main() { n=23; memset(a,0,sizeof(a)); solve(); printf("%d的最優分解方案\n",n); int mul=1; printf(" 分解的數: "); for (int i=0;i<=k;i++) if (a[i]!=0) { printf("%d ",a[i]); mul*=a[i]; } printf("\n 乘積最大值: %d\n",mul); } 上述程序的執行結果如圖 1.44 所示。 圖 1.44 程序執行結果 10. 解：采用貪心思路，首先按體重遞增排序；再考慮前后的兩個人（最輕者和最重者），分別用 i、j 指向：若 w[i]+w[j]≤C，說明這兩個人可以同乘（執行 i++，j--），否則 w[j]單乘（執行 j--），若最后只剩余一個人，該人只能單乘。 對應的完整程序如下： #include <stdio.h> #include <algorithm> using namespace std; #define MAXN 101 //問題表示int n=7; int w[]={50,65,58,72,78,53,82}; int C=150; //求解結果表示int bests=0; void Boat() { sort(w,w+n); int i=0; //求解乘船問題 //遞增排序 int j=n - 1; while (i<=j) { if(i==j) //剩下最后一個人 { printf(" 一艘船: %d\n",w[i]); bests++; break; } if (w[i]+w[j]<=C) //前后兩個人同乘 { printf(" 一艘船: %d %d\n",w[i],w[j]); bests++; i++; j--; } else //w[j]單乘 { printf(" 一艘船: %d\n",w[j]); bests++; j--; } } } void main() { printf("求解結果:\n"); Boat(); printf("最少的船數=%d\n",bests); } 上述程序的執行結果如圖 1.45 所示。 圖 1.45 程序執行結果 11. 解：采用貪心思路。每次都在還未安排的容量最大的會議室安排盡可能多的參會人數，即對於每個會議室，都安排當前還未安排的會議中，參會人數最多的會議。若能容納下，則選擇該會議，否則找參會人數次多的會議來安排，直到找到能容納下的會議。 對應的完整程序如下： #include <stdio.h> #include <algorithm> using namespace std; //問題表示 int n=4; //會議個數 int m=4; //會議室個數 int A[]={3,4,3,1}; int B[]={1,2,2,6}; //求解結果表示int ans=0; void solve() //求解算法 { sort(A,A+n); //遞增排序 sort(B,B+m); //遞增排序 int i=n-1,j=m-1; //從最多人數會議和最多容納人數會議室開始 for(i;i>=0;i--) { if(A[i]<=B[j] && j>=0) { ans++; //不滿足條件，增加一個會議室 j--; } } } void main() { solve(); printf("%d\n",ans); //輸出2 } 12. 解：與《教程》例 7.2 類似，會場對應蓄欄，只是這里僅僅求會場個數，即最大兼容活動子集的個數。對應的完整程序如下： #include <stdio.h> #include <string.h> #include <algorithm> using namespace std; #define MAX 51 //問題表示 struct Action //活動的類型聲明 { int b; int e; //活動起始時間 //活動結束時間 bool operator<(const Action &s) const //重載<關系函數 { if (e==s.e) //結束時間相同按開始時間遞增排序 return b<=s.b; else //否則按結束時間遞增排序 return e<=s.e; } }; int n=5; Action A[]={{0},{1,10},{2,4},{3,6},{5,8},{4,7}}; //下標0不用 //求解結果表示 int ans; //最少會場個數 void solve() //求解最大兼容活動子集 { bool flag[MAX]; //活動標志 memset(flag,0,sizeof(flag)); sort(A+1,A+n+1); //A[1..n]按指定方式排序 ans=0; //會場個數 for (int j=1;j<=n;j++) { if (!flag[j]) { flag[j]=true; int preend=j; //前一個兼容活動的下標 for (int i=preend+1;i<=n;i++) { if (A[i].b>=A[preend].e && !flag[i]) { } preend=i; flag[i]=true; } ans++; //增加一個最大兼容活動子集 } } } void main() { solve(); printf("求解結果\n"); printf(" 最少會場個數: %d\n",ans); //輸出4 } 13. 解：采用貪心思路。從第 1 列開始每次查找 a[i][j]元素上、中、下 3 個對應數中的最小數。對應的程序如下： #include <stdio.h> #define M 12 #define N 110 int m=5, n=6; int a[M][N]={{3,4,1,2,8,6},{6,1,8,2,7,4},{5,9,3,9,9,5},{8,4,1,3,2,6},{3,7,2,8,6,4}}; int minRow,minCol; int minValue(int i, int j) //求a[i][j]有方上、中、下3個數的最小數,同時要把行標記錄下來 { int s = (i == 0) ? m - 1 : i - 1; int x = (i == m - 1) ? 0 : i + 1; minRow = s; minRow = a[i][j+1] < a[minRow][j+1] ? i : minRow; minRow = a[x][j+1] < a[minRow][j+1] ? x : minRow; minRow = a[minRow][j+1] == a[s][j+1] && minRow > s ? s : minRow; minRow = a[minRow][j+1] == a[i][j+1] && minRow > i ? i : minRow; minRow = a[minRow][j+1] == a[x][j+1] && minRow > x ? x : minRow; return a[minRow][j+1]; } void solve() { int i,j,min; for (j=n-2; j>=0; j--) for (i=0; i<m; i++) a[i][j]+= minValue(i,j); min=a[0][0]; minRow=0; for (i=1; i<m; i++) //在第一列查找最小代價的行 if (a[i][0]<min) { min=a[i][0]; minRow=i; } for (j=0; j<n; j++) { printf("%d",minRow+1); if (j<n-1) printf(" "); minValue(minRow, j); } printf("\n%d\n",min); } void main() { solve(); } 1.8 第 8 章─動態規划 1.8.1 練習題 1. 下列算法中通常以自底向上的方式求解最優解的是（ ）。 A. 備忘錄法 B.動態規划法 C.貪心法 D.回溯法 2. 備忘錄方法是（ ）算法的變形。 A. 分治法 B.回溯法 C.貪心法 D.動態規划法 3. 下列是動態規划算法基本要素的是（ ）。 A. 定義最優解 B.構造最優解 C.算出最優解 D.子問題重疊性質 4. 一個問題可用動態規划算法或貪心算法求解的關鍵特征是問題的（ ）。 A. 貪心選擇性質 B.重疊子問題 C.最優子結構性質 D.定義最優解 5. 簡述動態規划法的基本思路。 6. 簡述動態規划法與貪心法的異同。 7. 簡述動態規划法與分治法的異同。 8. 下列算法中哪些屬於動態規划算法？ （1） 順序查找算法 （2） 直接插入排序算法 （3） 簡單選擇排序算法 （4） 二路歸並排序算法 9. 某個問題對應的遞歸模型如下： f(1)=1 f(2)=2 f(n)=f(n-1)+f(n-2)+…+f(1)+1 當 n>2 時 可以采用如下遞歸算法求解： long f(int n) { if (n==1) return 1; if (n==2) return 2; long sum=1; for (int i=1;i<=n-1;i++) sum+=f(i); return sum; } 但其中存在大量的重復計算，請采用備忘錄方法求解。 10. 第 3 章中的實驗 4 采用分治法求解半數集問題，如果直接遞歸求解會存在大量重復計算，請改進該算法。 11. 設計一個時間復雜度為 O(n2)的算法來計算二項式系數C k （k≤n）。二項式系數 Ck 的求值過程如下： 𝐶0 = 1 𝐶𝑖 = 1 𝐶𝑗 = 𝐶𝑗 ‒ 1 + 𝐶 𝑗 當 i≥j 𝑖 𝑖 ‒ 1 𝑖 ‒ 1 12. 一個機器人只能向下和向右移動，每次只能移動一步，設計一個算法求它從 （0，0）移動到（m，n）有多少條路徑。 13. 兩種水果雜交出一種新水果，現在給新水果取名，要求這個名字中包含了以前兩種水果名字的字母，並且這個名字要盡量短。也就是說以前的一種水果名字 arr1 是新水果名字 arr 的子序列，另一種水果名字 arr2 也是新水果名字 arr 的子序列。設計一個算法求arr。 例如：輸入以下 3 組水果名稱： apple peach ananas banana pear peach 輸出的新水果名稱如下： appleach bananas pearch 1.8.2 練習題參考答案 1. 答：B。 2. 答：D。 3. 答：D。 4. 答：C。 5. 答：動態規划法的基本思路是將待求解問題分解成若干個子問題，先求子問題的解，然后從這些子問題的解得到原問題的解。 6. 答：動態規划法的 3 個基本要素是最優子結構性質、無后效性和重疊子問題性質，而貪心法的兩個基本要素是貪心選擇性質和最優子結構性質。所以兩者的共同點是都要求問題具有最優子結構性質。 兩者的不同點如下： （1） 求解方式不同，動態規划法是自底向上的，有些具有最優子結構性質的問題只能用動態規划法，有些可用貪心法。而貪心法是自頂向下的。 （2） 對子問題的依賴不同，動態規划法依賴於各子問題的解，所以應使各子問題最優，才能保證整體最優；而貪心法依賴於過去所作過的選擇，但決不依賴於將來的選擇， 也不依賴於子問題的解。 7. 答：兩者的共同點是將待求解的問題分解成若干子問題，先求解子問題，然后再從這些子問題的解得到原問題的解。 兩者的不同點是：適合於用動態規划法求解的問題，分解得到的各子問題往往不是相互獨立的（重疊子問題性質），而分治法中子問題相互獨立；另外動態規划法用表保存已求解過的子問題的解，再次碰到同樣的子問題時不必重新求解，而只需查詢答案，故可獲得多項式級時間復雜度，效率較高，而分治法中對於每次出現的子問題均求解，導致同樣的子問題被反復求解，故產生指數增長的時間復雜度，效率較低。 8. 答：判斷算法是否具有最優子結構性質、無后效性和重疊子問題性質。（2）、（3）和（4）均屬於動態規划算法。 9. 解：設計一個 dp 數組，dp[i]對應 f(i)的值，首先 dp 的所有元素初始化為 0，在計算 f(i)時，若 dp[0]>0 表示 f(i)已經求出，直接返回 dp[i]即可，這樣避免了重復計算。對應的算法如下： long dp[MAX]; //dp[n]保存f(n)的計算結果 long f1(int n) { if (n==1) { dp[n]=1; return dp[n]; } if (n==2) { dp[n]=2; return dp[n]; } if (dp[n]>0) return dp[n]; long sum=1; for (int i=1;i<=n-1;i++) sum+=f1(i); dp[n]=sum; return dp[n]; } 10. 解：設計一個數組 a，其中 a[i]=f(i)，首先將 a 的所有元素初始化為 0，當 a[i]>0 時表示對應的 f(i)已經求出，直接返回就可以了。對應的完整程序如下： #include <stdio.h> #include <string.h> #define MAXN 201 //問題表示int n; int a[MAXN]; int fa(int i) //求a[i] { int ans=1; if (a[i]>0) return a[i]; for(int j=1;j<=i/2;j++) ans+=fa(j); a[i]=ans; return ans; } int solve(int n) //求set(n)的元素個數 { memset(a,0,sizeof(a)); a[1]=1; return fa(n); } void main() { n=6; printf("求解結果\n"); printf(" n=%d時半數集元素個數=%d\n",n,solve(n)); } 11. 解：定義 C(i，j)= Cij ，i≥j。則有如下遞推計算公式：C(i，j)=C(i-1，j-1)+C(i- 1，j)，初始條件為 C(i，0)=1，C(i，i)=1。可以根據初始條件由此遞推關系計算 C(n，k)， 即Ck 。對應的程序如下： #include <stdio.h> #define MAXN 51 #define MAXK 31 //問題表示int n,k; //求解結果表示 int C[MAXN][MAXK]; void solve() { int i,j; for (i=0;i<=n;i++) { C[i][i]=1; C[i][0]=1; } for (i=1;i<=n;i++) for (j=1;j<=k;j++) C[i][j]=C[i-1][j-1]+C[i-1][j]; } void main() { n=5,k=3; solve(); printf("%d\n",C[n][k]); //輸出10 } 顯然，solve()算法的時間復雜度為 O(n2)。 12. 解：設從（0，0）移動到（i，j）的路徑條數為 dp[i][j]，由於機器人只能向下和向右移動，不同於迷宮問題（迷宮問題由於存在后退，不滿足無后效性，不適合用動態規划法求解）。對應的狀態轉移方程如下： dp[0][j]=1 dp[i][0]=1 dp[i][j]=dp[i][j-1]+dp[i-1][j] i、j>0 最后結果是 dp[m][n]。對應的程序如下： #include <stdio.h> #include <string.h> #define MAXX 51 #define MAXY 51 //問題表示int m,n; //求解結果表示 int dp[MAXX][MAXY]; void solve() { int i,j; dp[0][0]=0; memset(dp,0,sizeof(dp)); for (i=1;i<=m;i++) dp[i][0]=1; for (j=1;j<=n;j++) dp[0][j]=1; for (i=1;i<=m;i++) for (j=1;j<=n;j++) dp[i][j]=dp[i][j-1]+dp[i-1][j]; } void main() { m=5,n=3; solve(); printf("%d\n",dp[m][n]); } 13. 解：本題目的思路是求 arr1 和 arr2 字符串的最長公共子序列，基本過程參見《教 程》第 8 章 8.5 節。對應的完整程序如下： #include <iostream> #include <string.h> #include <vector> #include <string> using namespace std; #define max(x,y) ((x)>(y)?(x):(y)) #define MAX 51 //序列中最多的字符個數 //問題表示 int m,n; string arr1,arr2; //求解結果表示 int dp[MAX][MAX]; //動態規划數組vector<char> subs; // 存 放 LCS void LCSlength() //求dp { int i,j; for (i=0;i<=m;i++) //將dp[i][0]置為0,邊界條件 dp[i][0]=0; for (j=0;j<=n;j++) //將dp[0][j]置為0,邊界條件 dp[0][j]=0; for (i=1;i<=m;i++) for (j=1;j<=n;j++) //兩重for循環處理arr1、arr2的所有字符 { if (arr1[i-1]==arr2[j-1]) //比較的字符相同 dp[i][j]=dp[i-1][j-1]+1; else //比較的字符不同 } dp[i][j]=max(dp[i][j-1],dp[i-1][j]); } void Buildsubs() //由dp構造從subs { int k=dp[m][n]; //k為arr1和arr2的最長公共子序列長度 int i=m; int j=n; while (k>0) //在subs中放入最長公共子序列(反向) if (dp[i][j]==dp[i-1][j]) i--; else if (dp[i][j]==dp[i][j-1]) j--; else { subs.push_back(arr1[i-1]); //subs中添加arr1[i-1] i--; j--; k--; } } voi { d main() cin >> arr1 >> arr2; //輸入arr1和arr2 m=arr1.length(); //m為arr1的長度 n=arr2.length(); //n為arr2的長度 LCSlength(); //求出dp Buildsubs(); //求出LCS cout << "求解結果" << endl; cout << " arr: "; vector<char>::reverse_iterator rit; for (rit=subs.rbegin();rit!=subs.rend();++rit) cout << *rit; cout << endl; cout << " 長 度 : " << dp[m][n] << endl; } 改為如下： 13. 解：本題目的思路是先求 arr1 和 arr2 字符串的最長公共子序列，基本過程參見 《教程》第 8 章 8.5 節，再利用遞歸輸出新水果取名。 算法中設置二維動態規划數組 dp，dp[i][j]表示 arr1[0..i-1]（i 個字母）和 arr2[0..j-1] （j 個字母）中最長公共子序列的長度。另外設置二維數組 b，b[i][j]表示 arr1 和 arr2 比較的 3 種情況：b[i][j]=0 表示 arr1[i-1]=arr2[j-1]，b[i][j]=1 表示 arr1[i-1]≠arr2[j-1]並且 dp[i- 1][j]>dp[i][j-1]，b[i][j]=2 表示 arr1[i-1]≠arr2[j-1]並且 dp[i-1][j]≤dp[i][j-1]。 對應的完整程序如下： #include <stdio.h> #include <string.h> #define MAX 51 //序列中最多的字符個數 //問題表示int m,n; char arr1[MAX],arr2[MAX]; //求解結果表示 int dp[MAX][MAX]; //動態規划數組 int b[MAX][MAX]; //存放arr1與arr2比較的3種情況 void Output(int i,int j) //利用遞歸輸出新水果取名 { if (i==0 && j==0) //輸出完畢 return; if(i==0) //arr1完畢，輸出arr2的剩余部分 { Output(i,j-1); printf("%c",arr2[j-1]); return; } else if(j==0) //arr2完畢，輸出arr1的剩余部分 { Output(i-1,j); printf("%c",arr1[i-1]); return; } if (b[i][j]==0) //arr1[i-1]=arr2[j-1]的情況 { Output(i-1,j-1); printf("%c",arr1[i-1]); return; } else if(b[i][j]==1) { Output(i-1,j); printf("%c",arr1[i-1]); return; } else { Output(i,j-1); printf("%c",arr2[j-1]); return; } } void LCSlength() //求dp { int i,j; for (i=0;i<=m;i++) //將dp[i][0]置為0,邊界條件 dp[i][0]=0; for (j=0;j<=n;j++) //將dp[0][j]置為0,邊界條件 dp[0][j]=0; for (i=1;i<=m;i++) for (j=1;j<=n;j++) //兩重for循環處理arr1、arr2的所有字符 { if (arr1[i-1]==arr2[j-1]) //比較的字符相同：情況0 { dp[i][j]=dp[i-1][j-1]+1; b[i][j]=0; } else if (dp[i-1][j]>dp[i][j-1]) //情況1 { dp[i][j]=dp[i-1][j]; b[i][j]=1; } else //dp[i-1][j]<=dp[i][j-1]:情況2 { dp[i][j]=dp[i][j-1]; b[i][j]=2; } } } void main() { int t; //輸入測試用例個數 printf("測試用例個數: "); scanf("%d",&t); while(t--) { scanf("%s",arr1); scanf("%s",arr2); memset(b,-1,sizeof(b)); m=strlen(arr1); n=strlen(arr2); LCSlength(); //m為arr1的長度 //n為arr2的長度 //求出dp printf("結果: "); Output(m,n); //輸出新水果取名 printf("\n"); } } 上述程序的一次執行結果如圖 1.46 所示。 圖 1.46 程序的一次執行結果 13. 解：本題目的思路是求 arr1 和 arr2 字符串的最長公共子序列，基本過程參見《教程》第 8 章 8.5 節。對應的完整程序如下： 然后再用遞歸思想，逐一輸出，得到的就是最后答案。 #include <iostream> #include <string.h> #include <vector> #include <string> using namespace std; #define max(x,y) ((x)>(y)?(x):(y)) #define MAX 51 //序列中最多的字符個數 //問題表示 int m,n; string arr1,arr2; //求解結果表示 int dp[MAX][MAX]; //動態規划數組vector<char> subs; // 存 放 LCS void LCSlength() //求dp { int i,j; for (i=0;i<=m;i++) //將dp[i][0]置為0,邊界條件 dp[i][0]=0; for (j=0;j<=n;j++) //將dp[0][j]置為0,邊界條件 dp[0][j]=0; for (i=1;i<=m;i++) for (j=1;j<=n;j++) //兩重for循環處理arr1、arr2的所有字符 { if (arr1[i-1]==arr2[j-1]) //比較的字符相同 dp[i][j]=dp[i-1][j-1]+1; else //比較的字符不同 } dp[i][j]=max(dp[i][j-1],dp[i-1][j]); } void Buildsubs() //由dp構造從subs { int k=dp[m][n]; //k為arr1和arr2的最長公共子序列長度 int i=m; int j=n; while (k>0) //在subs中放入最長公共子序列(反向) if (dp[i][j]==dp[i-1][j]) i--; else if (dp[i][j]==dp[i][j-1]) j--; else { subs.push_back(arr1[i-1]); //subs中添加arr1[i-1] i--; j--; k--; } } voi { d main() cin >> arr1 >> arr2; //輸入arr1和arr2 m=arr1.length(); //m為arr1的長度 n=arr2.length(); //n為arr2的長度 LCSlength(); //求出dp Buildsubs(); //求出LCS cout << "求解結果" << endl; cout << " arr: "; vector<char>::reverse_iterator rit; for (rit=subs.rbegin();rit!=subs.rend();++rit) cout << *rit; cout << endl; cout << " 長 度 : " << dp[m][n] << endl; } 上述程序的一次執行結果如圖 1.46 所示。 圖 1.46 程序的一次執行結果 1.9 第 9 章─圖算法設計 1.9.1 練習題 1. 以下不屬於貪心算法的是（ ）。 A.Prim 算法 B.Kruskal 算法 C.Dijkstra 算法 D.深度優先遍歷 2. 一個有 n 個頂點的連通圖的生成樹是原圖的最小連通子圖，且包含原圖中所有 n 個頂點，並且有保持圖聯通的最少的邊。最大生成樹就是權和最大生成樹，現在給出一個無向帶權圖的鄰接矩陣為{{0，4，5，0，3}，{4，0，4，2，3}，{5，4，0，2，0}，{0， 2，2，0，1}，{3，3，0，1，0}}，其中權為 0 表示沒有邊。一個圖為求這個圖的最大生成樹的權和是（ ）。 A.11 B.12 C.13 D.14 E.15 3. 某個帶權連通圖有 4 個以上的頂點，其中恰好有 2 條權值最小的邊，盡管該圖的最小生成樹可能有多個，而這 2 條權值最小的邊一定包含在所有的最小生成樹中嗎？如果有 3 條權值最小的邊呢？ 4. 為什么 TSP 問題采用貪心算法求解不一定得到最優解？ 5. 求最短路徑的 4 種算法適合帶權無向圖嗎？ 6. 求單源最短路徑的算法有 Dijkstra 算法、Bellman-Ford 算法和 SPFA 算法，比較這些算法的不同點。 7. 有人這樣修改 Dijkstra 算法以便求一個帶權連通圖的單源最長路徑，將每次選擇dist 最小的頂點 u 改為選擇最大的頂點 u，將按路徑長度小進行調整改為按路徑長度大調整。這樣可以求單源最長路徑嗎？ 8. 給出一種方法求無環帶權連通圖（所有權值非負）中從頂點 s 到頂點 t 的一條最長簡單路徑。 9. 一個運輸網絡如圖 1.47 所示，邊上數字為（c(i，j)，b(i，j)），其中 c(i，j)表示容量，b(i，j)表示單位運輸費用。給出從 1、2、3 位置運輸貨物到位置 6 的最小費用最大流的過程。 10. 本教程中的 Dijkstra 算法采用鄰接矩陣存儲圖，算法時間復雜度為 O(n2)。請你從各個方面考慮優化該算法，用於求源點 v 到其他頂點的最短路徑長度。 11. 有一個帶權有向圖 G（所有權為正整數），采用鄰接矩陣存儲。設計一個算法求其中的一個最小環。 圖 1.47 一個運輸網絡 1.9.2 練習題參考答案 1. 答：D。 2. 答：采用類似 Kurskal 算法來求最大生成樹，第 1 步取最大邊（0，2），第 2 步取 邊（0，1），第 3 步取邊（0，4），第 4 步取最大邊（1，3），得到的權和為 14。答案為 D。 3. 答：這 2 條權值最小的邊一定包含在所有的最小生成樹中，因為按 Kurskal 算法一定首先選中這 2 條權值最小的邊。如果有 3 條權值最小的邊，就不一定了，因為首先選中這 3 條權值最小的邊有可能出現回路。 4. 答：TSP 問題不滿足最優子結構性質，如（0，1，2，3，0）是整個問題的最優解，但（0，1，2，0）不一定是子問題的最優解。 5. 答：都適合帶權無向圖求最短路徑。 6. 答：Dijkstra 算法不適合存在負權邊的圖求單源最短路徑，其時間復雜度為 O(n2)。Bellman-Ford 算法和 SPFA 算法適合存在負權邊的圖求單源最短路徑，但圖中不能 存在權值和為負的環。Bellman-Ford 算法的時間復雜度為 O(ne)，而 SPFA 算法的時間復雜度為 O(e)，所以 SPFA 算法更優。 7. 答：不能。Dijkstra 算法本質上是一種貪心算法，而求單源最長路徑不滿足貪心選擇性質。 8. 答：Bellman-Ford 算法和 SPFA 算法適合存在負權邊的圖求單源最短路徑。可以將圖中所有邊權值改為負權值，求出從頂點 s 到頂點 t 的一條最短簡單路徑，它就是原來圖中從頂點 s 到頂點 t 的一條最長簡單路徑。 9. 答：為該運輸網絡添加一個虛擬起點 0，它到 1、2、3 位置運輸費用為 0，容量分別為到 1、2、3 位置運輸容量和，如圖 1.48 所示，起點 s=0，終點 t=6。 圖 1.48 添加一個虛擬起點的運輸網絡 首先初始化 f 為零流，最大流量 maxf=0，最小費用 mincost=0，采用最小費用最大流算法求解過程如下： （1） k=0，求出 w 如下： 求出從起點 0 到終點 6 的最短路徑為 0→1→4→6，求出最小調整量=4，f[4][6]調整為 4，f[1][4]調整為 4，f[0][1]調整為 4，mincost=20，maxf=4。 （2） k=1，求出 w 如下： 求出從起點 0 到終點 6 的最短路徑為 0→2→4→6，求出最小調整量=3，f[4][6]調整 為 7，f[2][4]調整為 3，f[0][2]調整為 3，mincost=44，maxf=4+3=7。 （3） k=2，求出 w 如下： 求出從起點 0 到終點 6 的最短路徑為 0→3→4→6，求出最小調整量=1，f[4][6]調整為 8，f[3][4]調整為 1，f[0][3]調整為 1，mincost=53，maxf=7+1=8。 （4） k=3，求出 w 如下： 求出從起點 0 到終點 6 的最短路徑為 0→3→5→6，求出最小調整量=2，f[5][6]調整為 2，f[3][5]調整為 2，f[0][3]調整為 3，mincost=83，maxf=8+2=10。 （5） k=4，求出 w 如下： 求出從起點 0 到終點 6 的最短路徑為 0→1→5→6，求出最小調整量=6，f[5][6]調整為 8，f[1][5]調整為 6，f[0][1]調整為 10，mincost=179，maxf=10+6=16。 （6） k=5，求出 w 如下： 求出從起點 0 到終點 6 的最短路徑為 0→1→5→6，求出最小調整量=1，f[5][6]調整 為 9，f[2][5]調整為 1，f[0][2]調整為 4，mincost=195，maxf=16+1=17。 （7） k=6，求出的 w 中沒有增廣路徑，調整結束。對應的最大流如下： 最終結果，maxf=17，mincost=195。即運輸的最大貨物量為 17，對應的最小總運輸費用為 195。 10. 解：從兩個方面考慮優化： （1） 在 Dijkstra 算法中，當求出源點 v 到頂點 u 的最短路徑長度后，僅僅調整從頂點 u 出發的鄰接點的最短路徑長度，而教程中的 Dijkstra 算法由於采用鄰接矩陣存儲圖， 需要花費 O(n)的時間來調整頂點 u 出發的鄰接點的最短路徑長度，如果采用鄰接表存儲圖，可以很快查找到頂點 u 的所有鄰接點並進行調整，時間為 O(MAX(圖中頂點的出 度))。 （2） 求目前一個最短路徑長度的頂點 u 時，教科書上的 Dijkstra 算法采用簡單比較方法，可以改為采用優先隊列（小根堆）求解。由於最多 e 條邊對應的頂點進隊，對應的時間為 O(log2e)。 對應的完整程序和測試數據算法如下： #include "Graph.cpp" #include <queue> #include <string.h> using namespace std; //包含圖的基本運算算法 ALGraph *G; //圖的鄰接表存儲結構，作為全局變量 struct Node //聲明堆中結點類型 { int i; //頂點編號 int v; //dist[i]值 friend bool operator<(const Node &a，const Node &b) //定義比較運算符 { return a.v > b.v; } }; void Dijkstra(int v，int dist[]) //改進的Dijkstra算法 { ArcNode *p; priority_queue<Node> qu; //創建小根堆 Node e; int S[MAXV]; //S[i]=1表示頂點i在S中， S[i]=0表示頂點i在U中 int i，j，u，w; memset(S，0，sizeof(S)); p=G->adjlist[v].firstarc; for (i=0;i<G->n;i++) dist[i]=INF; while (p!=NULL) { w=p->adjvex; dist[w]=p->weight; //距離初始化 e.i=w; e.v=dist[w]; //將v的出邊頂點進隊qu qu.push(e); p=p->nextarc; } S[v]=1; //源點編號v放入S中 for (i=0;i<G->n-1;i++) //循環直到所有頂點的最短路徑都求出 { e=qu.top(); qu.pop(); //出隊e u=e.i; //選取具有最小最短路徑長度的頂點u S[u]=1; //頂點u加入S中 p=G->adjlist[u].firstarc; while (p!=NULL) //考察從頂點u出發的所有相鄰點 { w=p->adjvex; if (S[w]==0) //考慮修改不在S中的頂點w的最短路徑長度 if (dist[u]+p->weight<dist[w]) { dist[w]=dist[u]+p->weight; //修改最短路徑長度 e.i=w; e.v=dist[w]; qu.push(e); //修改最短路徑長度的頂點進隊 } p=p->nextarc; } } } void Disppathlength(int v，int dist[]) //輸出最短路徑長度 { printf("從%d頂點出發的最短路徑長度如下:\n"，v); for (int i=0;i<G->n;++i) if (i!=v) printf(" 到頂點%d: %d\n"，i，dist[i]); } void main() { int A[MAXV][MAXV]={ {0，4，6，6，INF，INF，INF}， {INF，0，1，INF，7，INF，INF}， {INF，INF，0，INF，6，4，INF}， {INF，INF，2，0，INF，5，INF}， {INF，INF，INF，INF，0，INF，6}， {INF，INF，INF，INF，1，0，8}， {INF，INF，INF，INF，INF，INF，0}}; int n=7， e=12; CreateAdj(G，A，n，e); //建立圖的鄰接表 printf("圖G的鄰接表:\n"); DispAdj(G); //輸出鄰接表 int v=0; int dist[MAXV]; Dijkstra(v，dist); //調用Dijkstra算法 Disppathlength(v，dist); //輸出結果 DestroyAdj(G); //銷毀圖的鄰接表 } 上述程序的執行結果如圖 1.49 所示。 圖 1.49 程序執行結果 其中 Dijkstra 算法的時間復雜度為 O(n(log2e+MAX(頂點的出度))，一般圖中最大頂點出度遠小於 e，所以進一步簡化時間復雜度為 O(nlog2e)。 11. 有一個帶權有向圖 G（所有權為正整數），采用鄰接矩陣存儲。設計一個算法求其中的一個最小環。 解：利用 Floyd 算法求出所有頂點對之間的最短路徑，若頂點 i 到 j 有最短路徑，而圖中又存在頂點 j 到 i 的邊，則構成一個環，在所有環中比較找到一個最小環並輸出。對應的程序如下： #include "Graph.cpp" //包含圖的基本運算算法#include <vector> using namespace std; void Dispapath(int path[][MAXV],int i,int j) //輸出頂點 i 到 j 的一條最短路徑 { vector<int> apath; //存放一條最短路徑中間頂點(反向) int k=path[i][j]; apath.push_back(j); //路徑上添加終點 while (k!=-1 && k!=i) //路徑上添加中間點 { apath.push_back(k); k=path[i][k]; } apath.push_back(i); //路徑上添加起點 for (int s=apath.size()-1;s>=0;s--) //輸出路徑上的中間頂點 printf("%d→",apath[s]); } int Mincycle(MGraph g,int A[MAXV][MAXV],int &mini,int &minj) //在圖 g 和 A 中的查找一個最小環 { int i,j,min=INF; for (i=0;i<g.n;i++) for (j=0;j<g.n;j++) if (i!=j && g.edges[j][i]<INF) { if (A[i][j]+g.edges[j][i]<min) { min=A[i][j]+g.edges[j][i]; mini=i; minj=j; } } return min; } void Floyd(MGraph g) //Floyd 算法求圖 g 中的一個最小環 { int A[MAXV][MAXV],path[MAXV][MAXV]; int i,j,k,min,mini,minj; for (i=0;i<g.n;i++) for (j=0;j<g.n;j++) { A[i][j]=g.edges[i][j]; if (i!=j && g.edges[i][j]<INF) path[i][j]=i; //頂點i到j有邊時 else path[i][j]=-1; //頂點i到j沒有邊時 } for (k=0;k<g.n;k++) //依次考察所有頂點 { for (i=0;i<g.n;i++) for (j=0;j<g.n;j++) if (A[i][j]>A[i][k]+A[k][j]) { A[i][j]=A[i][k]+A[k][j]; //修改最短路徑長度 path[i][j]=path[k][j]; //修改最短路徑 } } min=Mincycle(g,A,mini,minj); if (min!=INF) { printf("圖中最小環："); Dispapath(path,mini,minj); //輸出一條最短路徑 printf("%d, 長度：%d\n",mini,min); } else printf(" 圖中沒有任何環\n"); } void main() { MGraph g; int A[MAXV][MAXV]={ {0,5,INF,INF},{INF,0,1,INF}, {3,INF,0,2}, {INF,4,INF,0}}; int n=4, e=5; CreateMat(g,A,n,e); //建立圖的鄰接矩陣 printf("圖G的鄰接矩陣:\n"); DispMat(g); //輸出鄰接矩陣 Floyd(g); } 上述程序的執行結果如圖 1.50 所示。 圖 1.50 程序執行結果 1.10 第 10 章─計算幾何 1.10.1 練習題 1. 對如圖 1.51 所示的點集 A，給出采用 Graham 掃描算法求凸包的過程及結果。 10 9 8 7 6 5 4 3 2 1 1 2 3 4 5 6 7 8 9 10 圖 1.51 一個點集 A 2. 對如圖 1.51 所示的點集 A，給出采用分治法求最近點對的過程及結果。 3. 對如圖 1.51 所示的點集 A，給出采用旋轉卡殼法求最遠點對的結果。 4. 對應 3 個點向量 p1、p2、p3，采用 S(p1，p2，p3)=(p2-p1)(p3-p1)/2 求它們構成的三角形面積，請問什么情況下計算結果為正？什么情況下計算結果為負？ 5. 已知坐標為整數，給出判斷平面上一點 p 是否在一個逆時針三角形 p1-p2-p3 內部的算法。 1.10.2 練習題參考答案 1. 答：采用 Graham 掃描算法求凸包的過程及結果如下： 求出起點 a0(1，1)。 排序后：a0(1，1) a1(8，1) a2(9，4) a3(5，4) a4(8，7) a5(5，6) a10(7，10) a9(3，5) a6(3，7) a7(4，10) a8(1，6) a11(0，3)。 先將 a0(1，1)進棧，a1(8，1)進棧，a2(9，4)進棧。處理點 a3(5，4)：a3(5，4)進棧。 處理點 a4(8，7)：a3(5，4)存在右拐關系，退棧，a4(8，7)進棧。 處理點 a5(5，6)：a5(5，6)進棧。 處理點 a10(7，10)：a5(5，6)存在右拐關系，退棧，a10(7，10)進棧。處理點 a9(3，5)：a9(3，5)進棧。 處理點 a6(3，7)：a9(3，5)存在右拐關系，退棧，a6(3，7)進棧。處理點 a7(4，10)：a6(3，7)存在右拐關系，退棧，a7(4，10)進棧。處理點 a8(1，6)：a8(1，6)進棧。 處理點 a11(0，3)：a11(0，3)進棧。 結果：n=8，凸包的頂點：a0(1，1) a1(8，1) a2(9，4) a4(8，7) a10(7，10) a7(4，10) a8(1，6) a11(0，3)。 2. 答：求解過程如下： 排序前：(1，1) (8，1) (9，4) (5，4) (8，7) (5，6) (3，7) (4，10) (1，6) (3，5) (7，10) (0，3)。按 x 坐標排序后：(0，3) (1，1) (1，6) (3，7) (3，5) (4，10) (5，4) (5，6) (7，10) (8，1) (8，7) (9，4)。按 y 坐標排序后：(1，1) (8，1) (0，3) (5，4) (9，4) (3，5) (1，6) (5，6) (3，7) (8，7) (4，10) (7，10)。 （1）中間位置 midindex=5，左部分：(0，3) (1，1) (1，6) (3，7) (3，5) (4，10)；右部分：(5，4) (5，6) (7，10) (8，1) (8，7) (9，4)；中間部分點集為 (0，3) (3，7) (4，10) (5，4) (5，6) (7，10) (8，7)。 （2）求解左部分：(0，3) (1，1) (1，6) (3，7) (3，5) (4，10)。 中間位置=2，划分為左部分 1：(0，3) (1，1) (1，6)，右部分 1：(3，7) (3，5) (4，10) 處理左部分 1：點數少於 4：求出最近距離=2.23607，即(0，3)和(1，1)之間的距離。處理右部分 1：點數少於 4：求出最近距離=2，即(3，7)和(3，5)之間的距離。 再考慮中間部分（中間部分最近距離=2.23）求出左部分 d1=2。 （3）求解右部分：(5，4) (5，6) (7，10) (8，1) (8，7) (9，4)。 中間位置=8，划分為左部分 2：(5，4) (5，6) (7，10)，右部分 2：(8，1) (8，7) (9， 4)。 處理左部分 2：點數少於 4，求出最近距離=2，即 (5，4)和(5，6)之間的距離。 處理右部分 2：點數少於 4，求出最近距離=3.16228，即(8，1)和(9，4)之間的距離。再考慮中間部分（中間部分為空）求出右部分 d2=2。 （4）求解中間部分點集：(0，3) (3，7) (4，10) (5，4) (5，6) (7，10) (8，7)。求出最 近距離 d3=5。 最終結果為：d=MIN{d1，d2，d3)=2。 3. 答：采用旋轉卡殼法求出兩個最遠點對是（1，1）和（7，10），最遠距離為 10.82。 4. 答：當三角形 p1-p2-p3 逆時針方向時，如圖 1.52 所示，p2-p1 在 p3-p1 的順時針方向上，(p2-p1)(p3-p1)>0，對應的面積(p2-p1)(p3-p1)/2 為正。 當三角形 p1-p2-p3 順時針方向時，如圖 1.53 所示，p2-p1 在 p3-p1 的逆時針方向上， (p2-p1)(p3-p1)<0，對應的面積(p2-p1)(p3-p1)/2 為負。 圖 1.52 p1-p2-p3 逆時針方向圖 圖 1.53 p1-p2-p3 逆時針方向 5. 答：用 S(p1，p2，p3)=(p2-p1)(p3-p1)/2 求三角形 p1、p2、p3 帶符號的的面積。如圖 1.54 所示，若 S(p，p2，p3)和 S(p，p3，p1)和 S(p，p1，p2)（3 個三角形的方向均為逆時針方向）均大於 0，表示 p 在該三角形內部。 p3 p1 p2 圖 1.54 一個點 p 和一個三角形 對應的程序如下： #include "Fundament.cpp" //包含向量基本運算算法 double getArea(Point p1,Point p2,Point p3) //求帶符號的面積 { return Det(p2-p1,p3-p1); } bool Intrig(Point p,Point p1,Point p2,Point p3) //判斷 p 是否在三角形 p1p2p3 的內部 { double area1=getArea(p,p2,p3); double area2=getArea(p,p3,p1); double area3=getArea(p,p1,p2); if (area1>0 && area2>0 && area3>0) return true; else return false; } void main() { printf("求解結果\n"); Point p1(0,0); Point p2(5,-4); Point p3(4,3); Point p4(3,1); Point p5(-1,1); printf(" p1:"); p1.disp(); printf("\n"); printf(" p2:"); p2.disp(); printf("\n"); printf(" p3:"); p3.disp(); printf("\n"); printf(" p4:"); p4.disp(); printf("\n"); printf(" p5:"); p5.disp(); printf("\n"); printf(" p1p2p3三角形面積: %g\n",getArea(p1,p2,p3)); printf(" p4在p1p2p3三角形內部: %s\n",Intrig(p4,p1,p2,p3)?"是":"不是"); printf(" p5在p1p2p3三角形內部: %s\n",Intrig(p5,p1,p2,p3)?"是":"不是"); } 上述程序的執行結果如圖 1.55 所示。 圖 1.55 程序執行結果 1.11 第 11 章─計算復雜性理論 1.11.1 練習題 1. 旅行商問題是 NP 問題嗎？ A.否 B.是 C.至今尚無定論 2. 下面有關 P 問題，NP 問題和 NPC 問題，說法錯誤的是（ ）。 A.如果一個問題可以找到一個能在多項式的時間里解決它的算法，那么這個問題就屬於 P 問題 B.NP 問題是指可以在多項式的時間里驗證一個解的問題C.所有的 P 類問題都是 NP 問題 D.NPC 問題不一定是個 NP 問題，只要保證所有的 NP 問題都可以約化到它即可 3. 對於《教程》例 11.2 設計的圖靈機，分別給出執行 f(3，2)和 f(2，3)的瞬像演變過程。 4. 什么是 P 類問題？什么是 NP 類問題？ 5. 證明求兩個 m 行 n 列的二維矩陣相加的問題屬於 P 類問題。 6. 證明求含有 n 個元素的數據序列中求最大元素的問題屬於 P 類問題。 7. 設計一個確定性圖靈機 M，用於計算后繼函數 S(n)=n+1（n 為一個二進制數），並給出求 1010001 的后繼函數值的瞬像演變過程。 1.11.2 練習題參考答案 1. 答：B。 2. 答：D。 3. 答：（1）執行 f(3，2)時，輸入帶上的初始信息為 000100B，其瞬像演變過程如 下： q0000100B B0q30110B BB01q210B Bq100100B Bq300110B BB011q20B B0q10100B q3B00110B BB01q311B B00q1100B Bq000110B BB0q3111B B001q200B BBq10110B BBq30111B B00q3110B BB0q1110B BBq00111B BBB1q211B BBB11q21B BBB111q2B BBB11q41B BBB1q41BB BBBq41BBB BBBq4BBBB BBB0q6BBB 最終帶上有一個 0，計算結果為 1。 （2）執行 f(2，3)時，輸入帶上的初始信息為 001000B，其瞬像演變過程如下： q0001000B Bq001000B B0q11000B B01q2000B B0q31100B Bq301100B q3 B01100B BBq31100B Bq001100B Bq3B1100B BBq11100B BBq01100B BB1q2100B BBBq5100B BB11q200B BBBBq500B BB1q3100B BBBBBq50B BBBBBBq5B BBBBBBBq6 最終帶上有零個 0，計算結果為 0。 4. 答：用確定性圖靈機以多項式時間界可解的問題稱為 P 類問題。用非確定性圖靈機以多項式時間界可解的問題稱為 NP 類問題。 5. 答：求兩個 m 行 n 列的二維矩陣相加的問題對應的算法時間復雜度為 O(mn)，所以屬於 P 類問題。 6. 答：求含有 n 個元素的數據序列中最大元素的問題的算法時間復雜度為 O(n)，所以屬於 P 類問題。 7. 解： q0 為初始狀態，q3 為終止狀態，讀寫頭初始時注視最右邊的格。δ 動作函數如下： δ(q0，0)→(q1，1，L) δ(q0，1)→(q2，0，L) δ(q0，B)→(q3，B，R) δ(q1，0)→(q1，0，L) δ(q1，1)→(q1，1，L) δ(q1，B)→(q3，B，L) δ(q2，0)→(q1，1，L) δ(q2，1)→(q2，0，L) δ(q2，B)→(q3，B，L) 求 10100010 的后繼函數值的瞬像演變過程如下： B1010001q00B B101000q111B B10100q1011B B1010q10011B B101q100011B B10q1100011B q3BB10100011B B1q10100011B Bq110100011B q1B10100011B 其結果為 10100011。 1.12 第 12 章─概率算法和近似算法 1.12.1 練習題 1. 蒙特卡羅算法是（ ）的一種。 A. 分枝限界算法 B.貪心算法 C.概率算法 D.回溯算法 2. 在下列算法中有時找不到問題解的是（ ）。 A. 蒙特卡羅算法 B.拉斯維加斯算法 C.舍伍德算法 D.數值概率算法 3. 在下列算法中得到的解未必正確的是（ ）。 A. 蒙特卡羅算法 B.拉斯維加斯算法 C.舍伍德算法 D.數值概率算法 4. 總能求得非數值問題的一個解，且所求得的解總是正確的是（ ）。 A. 蒙特卡羅算法 B.拉斯維加斯算法 C.數值概率算法 D.舍伍德算法 5. 目前可以采用（ ）在多項式級時間內求出旅行商問題的一個近似最優解。 A. 回溯法 B.蠻力法 C.近似算法 D.都不可能 6. 下列敘述錯誤的是（ ）。 A.概率算法的期望執行時間是指反復解同一個輸入實例所花的平均執行時間B.概率算法的平均期望時間是指所有輸入實例上的平均期望執行時間 C.概率算法的最壞期望事件是指最壞輸入實例上的期望執行時間 D.概率算法的期望執行時間是指所有輸入實例上的所花的平均執行時間 7. 下列敘述錯誤的是（ ）。 A.數值概率算法一般是求數值計算問題的近似解B.Monte Carlo 總能求得問題的一個解，但該解未必正確 C.Las Vegas 算法的一定能求出問題的正確解 D.Sherwood 算法的主要作用是減少或是消除好的和壞的實例之間的差別 8. 近似算法和貪心法有什么不同？ 9. 給定能隨機生成整數 1 到 5 的函數 rand5()，寫出能隨機生成整數 1 到 7 的函數rand7()。 1.12.2 練習題參考答案 1. 答：C。 2. 答：B。 3. 答：A。 4. 答：D。 5. 答：C。 6. 答：對概率算法通常討論平均的期望時間和最壞的期望時間，前者指所有輸入實例上平均的期望執行時間，后者指最壞的輸入實例上的期望執行時間。答案為 D。 7. 答：一旦用拉斯維加斯算法找到一個解，那么這個解肯定是正確的，但有時用拉斯維加斯算法可能找不到解。答案為 C。 8. 答：近似算法不能保證得到最優解。貪心算法不一定是近似算法，如果可以證明 決策既不受之前決策的影響，也不影響后續決策，則貪心算法就是確定的最優解算法。 9. 解：通過 rand5()*5+rand5()產生 6，7，8，9，…，26，27，28，29，30 這 25 個整數，每個整數 x 出現的概率相等，取前面 3*7=21 個整數，舍棄后面的 4 個整數，將{6， 7，8}轉化成 1，{9，10，11}轉化成 2，以此類推，即由 y= (x-3)/3 為最終結果。對應的程序如下： #include <stdio.h> #include <stdlib.h> #include <time.h> //包含產生隨機數的庫函數 int rand5() //產生一個[1,5]的隨機數 { int a=1,b=5; return rand()%(b-a+1)+a; } int rand7() //產生一個[1,7]的隨機數 { int x; do { x=rand5()*5+rand5(); } while (x>26); int y=(x-3)/3; return y; } void main() { srand((unsigned)time(NULL)); //隨機種子 for (int i=1;i<=20;i++) //輸出 20 個[1,7]的隨機數 printf("%d ",rand7()); printf("\n"); } 上述程序的一次執行結果如圖 1.56 所示。 圖 1.56 程序執行結果
from 算法設計與分析 - 李春葆 - 第二版 - pdf->word v1 - ggjong - 博客園 (cnblogs.com)