【分析】算法分析与设计作业参考答案

算法设计与分析习题答案算法设计与分析是计算机科学中一个重要的领域，它涉及到算法的创建、优化以及评估。

以下是一些典型的算法设计与分析习题及其答案。

习题1：二分查找算法问题描述：给定一个已排序的整数数组，编写一个函数来查找一个目标值是否存在于数组中。

答案：二分查找算法的基本思想是将数组分成两半，比较中间元素与目标值的大小，如果目标值等于中间元素，则查找成功；如果目标值小于中间元素，则在左半部分继续查找；如果目标值大于中间元素，则在右半部分继续查找。

这个过程会不断重复，直到找到目标值或搜索范围为空。

```pythondef binary_search(arr, target):low, high = 0, len(arr) - 1while low <= high:mid = (low + high) // 2if arr[mid] == target:return Trueelif arr[mid] < target:low = mid + 1else:high = mid - 1return False```习题2：归并排序算法问题描述：给定一个无序数组，使用归并排序算法对其进行排序。

答案：归并排序是一种分治算法，它将数组分成两半，分别对这两半进行排序，然后将排序好的两半合并成一个有序数组。

```pythondef merge_sort(arr):if len(arr) > 1:mid = len(arr) // 2left_half = arr[:mid]right_half = arr[mid:]merge_sort(left_half)merge_sort(right_half)i = j = k = 0while i < len(left_half) and j < len(right_half): if left_half[i] < right_half[j]:arr[k] = left_half[i]i += 1else:arr[k] = right_half[j]j += 1k += 1while i < len(left_half):arr[k] = left_half[i]i += 1k += 1while j < len(right_half):arr[k] = right_half[j]j += 1k += 1arr = [38, 27, 43, 3, 9, 82, 10]merge_sort(arr)print("Sorted array is:", arr)```习题3：动态规划求解最长公共子序列问题问题描述：给定两个序列，找到它们的最长公共子序列。

《算法分析与设计》作业( 一)本课程作业由两部分组成。

第一部分为”客观题部分”, 由15个选择题组成, 每题1分, 共15分。

第二部分为”主观题部分”,由简答题和论述题组成, 共15分。

作业总分30分, 将作为平时成绩记入课程总成绩。

客观题部分:一、选择题( 每题1分, 共15题)1、递归算法: ( C )A、直接调用自身B、间接调用自身C、直接或间接调用自身 D、不调用自身2、分治法的基本思想是将一个规模为n的问题分解为k个规模较小的字问题, 这些子问题: ( D )A、相互独立B、与原问题相同C、相互依赖D、相互独立且与原问题相同3、备忘录方法的递归方式是:( C )A、自顶向下B、自底向上C、和动态规划算法相同D、非递归的4、回溯法的求解目标是找出解空间中满足约束条件的:( A )A、所有解B、一些解C、极大解D、极小解5、贪心算法和动态规划算法共有特点是: ( A )A、最优子结构B、重叠子问题C、贪心选择D、形函数6、哈夫曼编码是: ( B)A、定长编码B、变长编码C、随机编码D、定长或变长编码7、多机调度的贪心策略是: ( A)A、最长处理时间作业优先B、最短处理时间作业优先C、随机调度D、最优调度8、程序能够不满足如下性质: ( D )A、零个或多个外部输入B、至少一个输出C、指令的确定性D、指令的有限性9、用分治法设计出的程序一般是: ( A )A、递归算法B、动态规划算法C、贪心算法D、回溯法10、采用动态规划算法分解得到的子问题:( C )A、相互独立B、与原问题相同C、相互依赖D、相互独立且与原问题相同11、回溯法搜索解空间的方法是: ( A )A、深度优先B、广度优先C、最小耗费优先D、随机搜索12、拉斯维加斯算法的一个显著特征是它所做的随机选性决策有可能导致算法: ( C )A、所需时间变化B、一定找到解C、找不到所需的解D、性能变差13、贪心算法能得到: ( C )A、全局最优解B、 0-1背包问题的解C、背包问题的解 D、无解14、能求解单源最短路径问题的算法是: ( A )A、分支限界法B、动态规划C、线形规划D、蒙特卡罗算法15、快速排序算法和线性时间选择算法的随机化版本是:( A )A、舍伍德算法B、蒙特卡罗算法C、拉斯维加斯算法D、数值随机化算法主观题部分:二、写出下列程序的答案( 每题2.5分, 共2题)1、请写出批处理作业调度的回溯算法。

算法分析与设计（答案）一：二分查找的递归实现算法import java.util.Arrays;import java.util.Scanner;public class BinSearch {public static int binsearch(int []a,int start,int stop,int b) {if(start>stop)return -1;int i=(start+stop)/2;if(a[i]==b)return i;if(a[i]>b)return binsearch(a,start,i-1,b);return binsearch(a,i+1,stop,b);}/***@param args*/public static void main(String[] args) {// TODO Auto-generated method stubScanner sc=new Scanner(System.in);System.out.println("输入数组长度");int n=sc.nextInt();int a[]=new int [n];System.out.println("输入数组元素");for(int i=0;i<n;i++){a[i]=sc.nextInt();}Arrays.sort(a);System.out.println("排序后的数组为");for(int i=0;i<a.length;i++){System.out.print(a[i]+" ");}System.out.println();System.out.println("输入要查找的数");int b=sc.nextInt();int x=binsearch(a,0,n-1,b);if(x==-1){System.out.println(b+"不在数组中，请输入另一个数");b=sc.nextInt();x=binsearch(a,0,n-1,b);}System.out.println(b+"在数组中的第"+(x+1)+"个位置");}}二：Ackerman函数的递归实现算法//Ackerman函数import java.util.Scanner;public class L {private static int Ackerman(int n,int m){int a,b;if(n==1&&m==0)a=2;else if(n==0&&m>=0)a=1;else if(m==1)a=n*2;else if(m==2)a=(int)Math.pow(2, n);else if(m==0&&n>=2)a=n+2;else {b=Ackerman(n-1,m);a=Ackerman(b,m-1);}return a;}public static void main(String[] args){Scanner sc=new Scanner(System.in);System.out.println("请先输入1个大于等于0的整数：");int N1=sc.nextInt();System.out.println("请再输入1个大于等于0的整数求Ackerman函数的递归：");int N2=sc.nextInt();System.out.println("Ackerman的值是"+Ackerman(N1,N2));}}三：全排列的递归实现算法import java.util.Scanner;public class AllSort{//全排列public static void main(String[] args) {Scanner sc=new Scanner(System.in);System.out.println("输入需要全排列的元素个数");int n=(char) sc.nextInt();int buf[]=new int [n];System.out.println("请依次输入每一个元素");for(int i=0;i<n;i++){buf[i]=sc.nextInt();}perm(buf,0,buf.length-1);}public static void perm(int[] buf,int start,int end){if(start==end){//当只要求对数组中一个元素进行全排列时，只要就按该数组输出即可（特殊情况）for(int i=0;i<=end;i++){System.out.print(buf[i]);}System.out.println();}else{//多个字母全排列（普遍情况）for(int i=start;i<=end;i++){//（让指针start分别指向每一个数） int temp=buf[start];//交换数组第一个元素与后续的元素buf[start]=buf[i];buf[i]=temp;perm(buf,start+1,end);//后续元素递归全排列temp=buf[start];//将交换后的数组还原buf[start]=buf[i];buf[i]=temp;}}}}四：快速排序的递归实现算法import java.util.Scanner;public class QuickSort {public static int []a;public static void quicksort(int p,int r){if(p<r){int q=partition(p,r);quicksort(p,q-1);quicksort(q+1,r);}}public static int partition(int p,int r){int i=p,j=r+1;int x=a[p];while(true){while(a[++i]<x&&i<r);while(a[--j]>x);if(i>=j)break;int temp=a[i];a[i]=a[j];a[j]=temp;}a[p]=a[j];a[j]=x;return j;}/***@param args*/public static void main(String[] args) { // TODO Auto-generated method stubScanner sc=new Scanner(System.in);System.out.println("输入要排序的数组长度");int n=sc.nextInt();a=new int[n];System.out.println("输入"+n+"个元素");for(int i=0;i<n;i++)a[i]=sc.nextInt();quicksort(0,n-1);System.out.println("排序后的数组为");for(int j=0;j<a.length;j++)System.out.print(a[j]+" ");}}五：整数划分的递归实现算法import java.io.IOException;import java.util.*;public class ZhengshuHuafen {public static int a=0 ;public static int Devide(int input, int base, int []pData, int index){ if(input<1||base<1)return 0;if(input==1||base==1){if(input==1){pData[index] = input;print(pData, index+1);}else{for(int k=0; k<input; k++){pData[index++] = base;}print(pData,index);}return 1;}if(input==base){pData[index] = base;print(pData,index+1);int temp = Devide(input,base-1,pData,index);return 1 + temp;}if(input<base){int temp = Devide(input,input,pData,index);return temp;}else{pData[index] = base;int temp1 = Devide(input-base,base,pData,index+1); int temp2 = Devide(input,base-1,pData,index);return temp1 + temp2;}}public static void print(int []pData ,int index){String s = new String();for(int i = 0 ; i < index - 1 ; i++){System.out.print(pData[i]+"+");s += String.valueOf(pData[i]);s += "+"; }System.out.println(pData[index-1]);s += String.valueOf(pData[index-1]) +"\r\n";}public static void main(String[] args) {int n ;Scanner in = new Scanner(System.in) ;System.out.print("请输入一个整数") ;n = in.nextInt() ;System.out.println("你刚才输入的数为"+n) ;int []pdata = new int[n] ;a=Devide(n, n, pdata, 0) ;System.out.println(""+a) ;}}//请输入一个整数100//你刚才输入的数为100//190569292六：合并排序的递归实现算法import java.util.Scanner;public class mergeSort {public static int []b;public static void mergeSort1(int []a,int left,int right) {if(left<right){int i=(left+right)/2;mergeSort1(a,left,i);mergeSort1(a,i+1,right);merge(a,b,left,i,right);copy(a,b,left,right);}}public static void merge(int []c,int []d,int l,int m,int r) {int i=l;int j=m+1;int k=l;while((i<=m)&&(j<=r))if(c[i]<=c[j])d[k++]=c[i++];else d[k++]=c[j++];if(i>m)for(int q=j;q<=r;q++)d[k++]=c[q];elsefor(int q=i;q<=m;q++)d[k++]=c[q];}public static void copy (int []c,int []b,int left,int right) {for(int i=left;i<=right;i++){c[i]=b[i];}}public static void main(String[]args) {Scanner sc=new Scanner(System.in);int n=sc.nextInt();b=new int[n];int []a;a=new int [n];for(int i=0;i<n;i++){a[i]=sc.nextInt();}mergeSort.mergeSort1(a,0,n-1);for(int j=0;j<=n-1;j++)System.out.print(a[j]+" ");}}结果。

算法设计与分析第三版第四章课后习题答案4.1 线性时间选择问题习题4.1问题描述：给定一个长度为n的无序数组A和一个整数k，设计一个算法，找出数组A中第k小的元素。

算法思路：本题可以使用快速选择算法来解决。

快速选择算法是基于快速排序算法的思想，通过递归地划分数组来找到第k小的元素。

具体步骤如下： 1. 选择数组A的一个随机元素x作为枢纽元。

2. 使用x将数组划分为两个子数组A1和A2，其中A1中的元素小于等于x，A2中的元素大于x。

3. 如果k等于A1的长度，那么x就是第k小的元素，返回x。

4. 如果k小于A1的长度，那么第k小的元素在A1中，递归地在A1中寻找第k小的元素。

5. 如果k大于A1的长度，那么第k小的元素在A2中，递归地在A2中寻找第k-A1的长度小的元素。

6. 递归地重复上述步骤，直到找到第k小的元素。

算法实现：public class LinearTimeSelection {public static int select(int[] A, int k) { return selectHelper(A, 0, A.length - 1, k);}private static int selectHelper(int[] A, int left, int right, int k) {if (left == right) {return A[left];}int pivotIndex = partition(A, left, righ t);int length = pivotIndex - left + 1;if (k == length) {return A[pivotIndex];} else if (k < length) {return selectHelper(A, left, pivotInd ex - 1, k);} else {return selectHelper(A, pivotIndex + 1, right, k - length);}}private static int partition(int[] A, int lef t, int right) {int pivotIndex = left + (right - left) / 2;int pivotValue = A[pivotIndex];int i = left;int j = right;while (i <= j) {while (A[i] < pivotValue) {i++;}while (A[j] > pivotValue) {j--;}if (i <= j) {swap(A, i, j);i++;j--;}}return i - 1;}private static void swap(int[] A, int i, int j) {int temp = A[i];A[i] = A[j];A[j] = temp;}}算法分析：快速选择算法的平均复杂度为O(n)，最坏情况下的复杂度为O(n^2)。

算法设计与分析第二版课后习题及解答算法设计与分析基础课后练习答案习题1.14.设计一个计算的算法,n是任意正整数。

除了赋值和比较运算,该算法只能用到基本的四则运算操作。

算法求 //输入:一个正整数n2//输出:。

step1:a1; step2:若a*an 转step 3,否则输出a; step3:aa+1转step 2;5. a.用欧几里德算法求gcd(31415,14142)。

b. 用欧几里德算法求gcd(31415,14142),比检查min{m,n}和gcd(m,n)间连续整数的算法快多少倍?请估算一下。

a. gcd31415, 14142 gcd14142, 3131 gcd3131, 1618 gcd1618, 1513 gcd1513, 105 gcd1513, 105 gcd105, 43 gcd43, 19 gcd19, 5 gcd5, 4 gcd4, 1 gcd1, 0 1.b.有a可知计算gcd(31415,14142)欧几里德算法做了11次除法。

连续整数检测算法在14142每次迭代过程中或者做了一次除法,或者两次除法,因此这个算法做除法的次数鉴于1?14142 和 2?14142之间,所以欧几里德算法比此算法快1?14142/11 ≈1300 与2?14142/11 ≈ 2600 倍之间。

6.证明等式gcdm,ngcdn,m mod n对每一对正整数m,n都成立.Hint:根据除法的定义不难证明:如果d整除u和v, 那么d一定能整除u±v;如果d整除u,那么d也能够整除u的任何整数倍ku.对于任意一对正整数m,n,若d能整除m和n,那么d一定能整除n和rm mod nm-qn;显然,若d能整除n和r,也一定能整除mr+qn和n。

数对m,n和n,r具有相同的公约数的有限非空集,其中也包括了最大公约数。

故gcdm,ngcdn,r7.对于第一个数小于第二个数的一对数字,欧几里得算法将会如何处理?该算法在处理这种输入的过程中,上述情况最多会发生几次?Hint:对于任何形如0mn的一对数字,Euclid算法在第一次叠代时交换m和n, 即gcdm,ngcdn,m并且这种交换处理只发生一次.8.a.对于所有1≤m,n≤10的输入, Euclid算法最少要做几次除法?1次b. 对于所有1≤m,n≤10的输入, Euclid算法最多要做几次除法?5次gcd5,8习题1.21.农夫过河P?农夫W?狼 G?山羊 C?白菜2.过桥问题1,2,5,10---分别代表4个人, f?手电筒4. 对于任意实系数a,b,c, 某个算法能求方程ax^2+bx+c0的实根,写出上述算法的伪代码可以假设sqrtx是求平方根的函数算法Quadratica,b,c//求方程ax^2+bx+c0的实根的算法//输入:实系数a,b,c//输出:实根或者无解信息If a≠0D←b*b-4*a*cIf D0temp←2*ax1←-b+sqrtD/tempx2←-b-sqrtD/tempreturn x1,x2else if D0 return ?b/2*ael se return “no real roots”else //a0if b≠0 return ?c/belse //ab0if c0 return “no real numbers”else return “no real roots”5. 描述将十进制整数表达为二进制整数的标准算法a.用文字描述b.用伪代码描述解答:a.将十进制整数转换为二进制整数的算法输入:一个正整数n输出:正整数n相应的二进制数第一步:用n除以2,余数赋给Kii0,1,2,商赋给n第二步:如果n0,则到第三步,否则重复第一步第三步:将Ki按照i从高到低的顺序输出b.伪代码算法 DectoBinn//将十进制整数n转换为二进制整数的算法//输入:正整数n//输出:该正整数相应的二进制数,该数存放于数组Bin[1n]中i1while n!0 doBin[i]n%2;nintn/2;i++;while i!0 doprint Bin[i];i--;9.考虑下面这个算法,它求的是数组中大小相差最小的两个元素的差.算法略对这个算法做尽可能多的改进.算法 MinDistanceA[0..n-1]//输入:数组A[0..n-1]//输出:the smallest distance d between two of its elements 习题1.3考虑这样一个排序算法,该算法对于待排序的数组中的每一个元素,计算比它小的元素个数,然后利用这个信息,将各个元素放到有序数组的相应位置上去.a.应用该算法对列表”60,35,81,98,14,47”排序b.该算法稳定吗?c.该算法在位吗?解:a. 该算法对列表”60,35,81,98,14,47”排序的过程如下所示:b.该算法不稳定.比如对列表”2,2*”排序c.该算法不在位.额外空间for S and Count[]4.古老的七桥问题第2章习题2.17.对下列断言进行证明:如果是错误的,请举例a. 如果tn∈Ogn,则gn∈Ωtnb.α0时,Θαgn Θgn解:a这个断言是正确的。

算法设计与分析习题解答第一章作业1.证明下列Ο、Ω和Θ的性质1）f=Ο(g)当且仅当g=Ω(f)证明：充分性。

若f=Ο(g)，则必然存在常数c1>0和n0，使得?n≥n0，有f≤c1*g(n)。

由于c1≠0，故g(n) ≥ 1/ c1 *f(n)，故g=Ω(f)。

必要性。

同理，若g=Ω(f)，则必然存在c2>0和n0，使得?n≥n0，有g(n) ≥ c2 *f(n).由于c2≠0，故f(n) ≤ 1/ c2*f(n)，故f=Ο(g)。

2）若f=Θ(g)则g=Θ(f)证明：若f=Θ(g)，则必然存在常数c1>0，c2>0和n0，使得?n≥n0，有c1*g(n) ≤f(n) ≤ c2*g(n)。

由于c1≠0，c2≠0，f(n) ≥c1*g(n)可得g(n) ≤ 1/c1*f(n)，同时，f(n) ≤c2*g(n)，有g(n) ≥ 1/c2*f(n)，即1/c2*f(n) ≤g(n) ≤ 1/c1*f(n)，故g=Θ(f)。

3）Ο(f+g)= Ο(max(f,g))，对于Ω和Θ同样成立。

证明：设F(n)= Ο(f+g)，则存在c1>0，和n1，使得?n≥n1，有F(n) ≤ c1 (f(n)+g(n))= c1 f(n) + c1g(n)≤ c1*max{f,g}+ c1*max{f,g}=2 c1*max{f,g}所以，F(n)=Ο(max(f,g))，即Ο(f+g)= Ο(max(f,g))对于Ω和Θ同理证明可以成立。

4）log(n!)= Θ(nlogn)证明：由于log(n!)=∑=ni i 1log ≤∑=ni n 1log =nlogn ，所以可得log(n!)= Ο(nlogn)。

由于对所有的偶数n 有，log(n!)= ∑=ni i 1log ≥∑=nn i i 2/log ≥∑=nn i n 2/2/log ≥(n/2)log(n/2)=(nlogn)/2-n/2。

《算法分析与设计》期末试题及参考答案一、简要回答下列问题：1.算法重要特性是什么？1. 确定性、可行性、输入、输出、有穷性2.2.算法分析的目的是什么？2. 分析算法占用计算机资源的情况，对算法做出比较和评价，设计出额更好的算法。

3.3.算法的时间复杂性与问题的什么因素相关？3. 算法的时间复杂性与问题的规模相关，是问题大小n的函数。

4.算法的渐进时间复杂性的含义？4．当问题的规模n趋向无穷大时，影响算法效率的重要因素是T(n)的数量级，而其他因素仅是使时间复杂度相差常数倍，因此可以用T(n)的数量级(阶)评价算法。

时间复杂度T(n)的数量级(阶)称为渐进时间复杂性。

5.最坏情况下的时间复杂性和平均时间复杂性有什么不同？5. 最坏情况下的时间复杂性和平均时间复杂性考察的是n固定时，不同输入实例下的算法所耗时间。

最坏情况下的时间复杂性取的输入实例中最大的时间复杂度：W(n) = max{ T(n，I) } , I∈Dn平均时间复杂性是所有输入实例的处理时间与各自概率的乘积和：A(n) =∑P(I)T(n，I) I∈Dn6.简述二分检索（折半查找）算法的基本过程。

6. 设输入是一个按非降次序排列的元素表A[i：j] 和x，选取A[(i+j)/2]与x比较，如果A[(i+j)/2]=x，则返回(i+j)/2，如果A[(i+j)/2]<x，则A[i：(i+j)/2-1]找x，否则在A[ (i+j)/2+1：j] 找x。

上述过程被反复递归调用。

7.背包问题的目标函数和贪心算法最优化量度相同吗？7. 不相同。

目标函数：获得最大利润。

最优量度：最大利润/重量比。

8.采用回溯法求解的问题，其解如何表示？有什么规定？8. 问题的解可以表示为n元组：（x1,x2,……x n），x i∈S i, S i为有穷集合，x i∈S i, （x1,x2,……x n）具备完备性，即（x1,x2,……x n）是合理的，则（x1,x2,……x i）(i<n)一定合理。

算法分析与设计试题及答案一、选择题1. 下列哪个是属于分治算法的例子？A. 冒泡排序B. 归并排序C. 顺序查找D. 选择排序答案：B2. 在排序算法中，时间复杂度最优的是：A. 冒泡排序B. 插入排序C. 归并排序D. 快速排序答案：C3. 哪个不是动态规划的特点？A. 具有重叠子问题B. 通过递归求解C. 需要保存子问题的解D. 具有最优子结构答案：B4. 在图的广度优先搜索算法中，使用的数据结构是：A. 栈B. 队列C. 数组D. 堆栈答案：B5. 在最小生成树算法中，下列哪个不属于贪心策略？A. Kruskal算法B. Prim算法C. Dijkstra算法D. Prim-Kruskal混合算法答案：C二、简答题1. 请简述分治算法的思想和应用场景。

答案：分治算法的思想是将原问题分解成若干个规模较小且类似的子问题，然后解决子问题，最后将子问题的解合并得到原问题的解。

其应用场景包括排序算法（如归并排序、快速排序）、搜索算法（如二分查找）等。

2. 什么是动态规划算法？请给出一个动态规划算法的示例。

答案：动态规划算法是一种通过将问题分解成子问题并解决子问题来解决复杂问题的方法。

它的特点是具有重叠子问题和最优子结构性质。

以斐波那契数列为例，可以使用动态规划算法求解每一项的值，而不需要重复计算。

3. 图的深度优先搜索和广度优先搜索有什么区别？答案：图的深度优先搜索（Depth First Search，DFS）是一种先访问子节点再访问兄弟节点的遍历算法，通常使用递归或者栈实现。

而广度优先搜索（Breadth First Search，BFS）则是以层次遍历的方式展开搜索，使用队列来实现。

DFS更适合用于搜索路径，BFS则适用于寻找最短路径等。

4. 请简述贪心算法的特点及其应用场景。

答案：贪心算法的特点是每一步都采取当前状态下最优的选择，以期望得到全局最优解。

然而，贪心算法并不一定能求解所有问题的最优解，但对于一些特定问题，贪心算法往往能得到近似最优解。

第二章递归习题导论4.1-17(/?) = 27(b / 2)+ 1=> M = 2T5 /2) + 1%)习题导论4.1-6Tin) = 2T(0) + 1做代换：m=log2n另 S(m)=T(2m )则有： S(/z?) = 2S(zz? / 2) + 1 化简有:S(m)=O(m) 所以 T(n)=O(logn)习题4.2-27(/7)= T(n / 3) + 7(2/7 / 3) + 劲 注意最长分支 2n/3-*(2n/3)2 -*(2n/3)3...-*(2n^)log3/2n 习题4.3-1a) T(n) = 4T(n/2) + nb) T(n) = 4T(n/2) + n 2c 取大于1/2小于1的数即可,如珈习题4.3-4f(n )/nlogba = n 2log n/n'°g"二 log nvn所以不满足规则3直接化简即可，T(n)=O(n 2log 2n)c) T(n) = 4T(n/2) + n 3情况 3, ◎ (r?). 验证 4f(n/2)=4(n/2)3=n 3/2^cn 3,这里7X2")27(2"/彳)+情况4 0(n 2)情况 2, © (n 2logn)第三章习题4.5注意三分Z—和三分Z二分割点的计算ml = (2low+high)^m2 = (low+2high)/3习题4.20主要是验证T(n/r) + T(0)＞|« n/r+O的数量级是否小于n的1次方(线性) 利用关系式：\n / r」n (/7 - r - 1) / /进行化简r=3：\r / 2~|~|_/2 / /_] / 2~| ＞ 2 z? / r / 2 = n / r」＞ (/? 一2) / 3则，刀一卜/2北刀 / 厂」/ 2] ＜ /? - (/? - 2) / 3 = 2/7 / 3 + 2 / 3 则，n〃 +羊n +厉超线性了r=7：\r / 2]\n / r\/ 2〕＞/ 7」/2 = 2山 / 7」＞ 2(刀一6) / 7则，n - \r / i\\n / /」/ 2〕v 刀一2(刀一6) / 7 = 5刀 / 7 + 12 / 7可证,当n＞48的时候，上式小于3伙则，n/7+3nA = 25n/28 ＜n 成立r=9：\r / 2][n / 厂」/ 2〕＞ 5[刀 / 9」/ 2 = (5 / 2)^/9」＞ 5(刀-8)/18n一\r / 2\[n / /」/ 2〕＜ 13/?/18 + 40/18可证，当n>20的时候，上式小于7n/8 则，n/9+7n/8 = 71n/72 <n 成立r=ll习题4.25肓接带入验证即可棋盘覆盖问题角上用一个骨牌覆盖，认为构造有特殊方格的区域，然后在四个区域上递归求解即可第四章中位数中位数习题导论9-2A）比较明显。

算法分析与设计作业及参考答案作业题目1、请分析冒泡排序算法的时间复杂度和空间复杂度，并举例说明其在实际中的应用场景。

2、设计一个算法，用于在一个未排序的整数数组中找到第二大的元素，并分析其时间复杂度。

3、比较贪心算法和动态规划算法的异同，并分别举例说明它们在解决问题中的应用。

参考答案1、冒泡排序算法时间复杂度：冒泡排序的基本思想是通过相邻元素的比较和交换，将最大的元素逐步“浮”到数组的末尾。

在最坏情况下，数组完全逆序，需要进行 n 1 轮比较和交换，每一轮比较 n i 次（i 表示当前轮数），所以总的比较次数为 n(n 1) ／ 2，时间复杂度为 O(n^2)。

在最好情况下，数组已经有序，只需要进行一轮比较，时间复杂度为 O(n)。

平均情况下，时间复杂度也为 O(n^2)。

空间复杂度：冒泡排序只在原数组上进行操作，不需要额外的存储空间，空间复杂度为 O(1)。

应用场景：冒泡排序算法简单易懂，对于规模较小的数组，或者对算法的简单性要求较高而对性能要求不是特别苛刻的场景，如对少量数据进行简单排序时，可以使用冒泡排序。

例如，在一个小型的学生成绩管理系统中，需要对一个班级的少量学生成绩进行排序展示，冒泡排序就可以满足需求。

2、找到第二大元素的算法以下是一种使用遍历的方法来找到未排序整数数组中第二大元素的算法：｀｀｀pythondef find_second_largest(arr)：largest ＝ arr0second_largest ＝ float(＇inf'）for num in arr:if num ＞ largest:second_largest ＝ largestlargest ＝ numelif num ＞ second_largest and num!＝ largest:second_largest ＝ numreturn second_largest｀｀｀时间复杂度分析：这个算法需要遍历数组一次，所以时间复杂度为O(n)。

算法设计与分析答案参考1、⽤Floyd 算法求下图每⼀对顶点之间的最短路径长度，计算矩阵D 0，D 1，D 2和D 3，其中D k [i, j]表⽰从顶点i 到顶点j 的不经过编号⼤于k 的顶点的最短路径长度。

解在每条边的矩阵⾏中依次加⼊顶点1,2,3，判断有⽆最短路径 2、设有n=2k 个运动员要进⾏循环赛，现设计⼀个满⾜以下要求的⽐赛⽇程表：①每个选⼿必须与其他n-1名选⼿⽐赛各⼀次；②每个选⼿⼀天⾄多只能赛⼀次；③循环赛要在最短时间内完成。

（1）如果n=2k ，循环赛最少需要进⾏⼏天；（2）当n=23=8时，请画出循环赛⽇程表。

解：（1）⾄少要进⾏n 天（2）如右图：3、对于下图使⽤Dijkstra 算法求由顶点a 到顶点h 的最短路径。

1 2 3 4 5 67 82 1 43 6 58 7解：⽤V 1表⽰已经找到最短路径的顶点，V 2表⽰与V 1中某个顶点相邻接且不在V 1中的顶点；E 1表⽰加⼊到最短路径中的边，E 2为与V 1中的顶点相邻接且距离最短的路径。

步骤 V 1 V 2 E 1E 2 1. {a}{b} {}{ab}2. {a,b} {d} {ab}{bd}3. {a,b,d}{c,f} {ab,bd}{dc,df} 4. {a,b,d,c} {f} {ab,bd}{df} 5. {a,b,c,d,f} {e} {ab,bd,dc,df}{fe}6. {a,b,c,d,e,f}{g} {ab,bd,dc,df,fe} {eg}7. {a,b,c,d,e,f,g} {h}{ab,bd,dc,df,fe,eg}{gh}8. {a,b,c,d,e,f,g,h} {} {ab,bd,de,df,fe,eg,gh} {} 结果：从a 到h 的最短路径为a b d fe g h →→→→→→，权值为18。

求所有顶点对之间的最短路径可以使⽤Dijkstra 算法，使其起始节点从a 循环到h ，每次求起始节点到其他节点的最短路径，最终可以求得所有顶点对之间的最短路径。

《算法分析与设计》练习题一答案1.程序书写格式应该遵循哪四个原则？参考答案：（1）正确使用缩进：一定要有缩进，否则代码的层次不明显。

（2）在一行内只写一条语句。

（3）, '}'位置不可随意放置。

（4）变量和运算符之间最好加1个空格2.什么是算法？参考答案：用计算机解决问题的过程可以分成三个阶段：分析问题、设计算法和实现算法。

算法可以理解为冇基本运算及规定的运算顺序所构成的完整的解题步骤，它是求解问题类的、机械的、统一的方法，它由有限多个步骤组成，对于问题类屮每个给定的具体问题，机械地执行这些步骤就可以得到问题的解答。

或者看成按照要求设计好的有限的确切的计算序列，并且这样的步骤和序列可以解决一类问题。

3.什么是线性结构？什么是非线性结构？参考答案：线性结构：数据逻辑结构屮的一类。

它的特征是若结构为非空集，则该结构有且只有一个开始结点和一个终端结点，并且所冇结点都冇R只冇一个直接前趋和一个直接后继。

线性表就是一个典型的线性结构。

栈、队列、串等都是线性结构。

非线性结构：数据逻辑结构中的另一大类，它的逻辑特征是一个结点可能有多个直接而趋和直接后继。

数组、广义表、树和图等数据结构都是非线性结构。

4.已知二叉树后序遍丿力序列是DABEC,屮序遍丿力序列是DEBAC,则前序遍历序列是什么？参考答案：前序遍历序列是CEDBA5.什么是数制？参考答案：数制是人们利用符号进行计数的一种科学方法。

数制也称计数制，是用一组固定的符号和统一的规则來表示数值的方法。

6.如果将十进制数106转换为八进制数，结果是多少？参考答案：1527.请问查找算法的效率用什么进行度量？参考答案：平均查找长度ASL：在查找其关键字等于给定值的过程小，需要和给定值进行比较的关键字个数的期望值称为查找成功吋的平均查找长度。

AS厶=£皿/=1其屮，n是结点的个数；是杳找第i个结点的概率,是找到第i个结点所需要的比较次数。

算法分析与设计教程习题解答第1章 算法引论1. 解：算法是一组有穷的规则，它规定了解决某一特定类型问题的一系列计算方法。

频率计数是指计算机执行程序中的某一条语句的执行次数。

多项式时间算法是指可用多项式函数对某算法进行计算时间限界的算法。

指数时间算法是指某算法的计算时间只能使用指数函数限界的算法。

2. 解：算法分析的目的是使算法设计者知道为完成一项任务所设计的算法的优劣，进而促使人们想方设法地设计出一些效率更高效的算法，以便达到少花钱、多办事、办好事的经济效果。

3. 解：事前分析是指求出某个算法的一个时间限界函数（它是一些有关参数的函数）；事后测试指收集计算机对于某个算法的执行时间和占用空间的统计资料。

4. 解：评价一个算法应从事前分析和事后测试这两个阶段进行，事前分析主要应从时间复杂度和空间复杂度这两个维度进行分析；事后测试主要应对所评价的算法作时空性能分布图。

5. 解：①n=11； ②n=12； ③n=982； ④n=39。

第2章 递归算法与分治算法1． 解：递归算法是将归纳法的思想应用于算法设计之中，递归算法充分地利用了计算机系统内部机能，自动实现调用过程中对于相关且必要的信息的保存与恢复；分治算法是把一个问题划分为一个或多个子问题，每个子问题与原问题具有完全相同的解决思路，进而可以按照递归的思路进行求解。

2． 解：通过分治算法的一般设计步骤进行说明。

3． 解：int fibonacci(int n) {if(n<=1) return 1;return fibonacci(n-1)+fibonacci(n-2); }4. 解：void hanoi(int n,int a,int b,int c) {if(n>0) {hanoi(n-1,a,c,b); move(a,b);hanoi(n-1,c,b,a); } } 5. 解：①22*2)(−−=n n f n② )log *()(n n n f O =6． 解：算法略。

《算法分析与设计》作业1、考虑,10≤≤i x 而不是x i ∈{0，1}的连续背包问题。

一种可行的贪婪策略是：按价值密度非递减的顺序检查物品，若剩余容量能容下正在考察的物品，将其装入；否则，往背包内装如此物品的一部分。

(a) 对于n=3，w=[100,10,10]，p=[20,15,15]，以及c=105，上述装入法获得结果是什么？(b)证明这种贪婪算法总能获得最优解。

(c) 用伪代码描述此算法。

答：（a ）利用贪婪算法，按价值密度考察的背包为w2，w3，w1；背包w2和w3重20，还可以容纳85，由于10≤≤i x ，背包w1还可以装入x1=0.85，则背包内物品总价值为15+15+20*0.85＝47.（b ）假设已按价值密度排好序，考察w1,w2,……,wi ，……，对应的价值为p1,p2,……,pi,……如果装到pi-1再装pi 时，恰好要取xi 个wi 。

（,10≤≤i x ） 因为比它价值密度大的都已装载完，所以此时获得的为最优解。

（c ）算法描述如下： template <class T>int ContainerLoading( int x[], T w[], T c, int n ) {int *t = new int[n+1]; IndirectSort(w, t, n); for( int i=1; i<=n; i++) x[i] = 0;for(i=1; i<=n && w[t[i]]<=c; i++){ x[t[i]] = 1; c += w[t[i]]; } delete []t; }2、证明当且仅当二分图没有覆盖时，下述算法找不到覆盖。

m＝0; //当前覆盖的大小对于A中的所有i，New[i]=Degree[i]对于B中的所有i，Cov[i]=falsewhile(对于A中的某些i，New[i]>0) {设v是具有最大的New[i]的顶点；C[m++]=v;for(所有邻接于v的顶点j) {If(!Cov[j]) {Cov[j] = true;对于所有邻接于j的顶点，使其New[k]减1}}}if (有些顶点未被覆盖) 失败else 找到一个覆盖2）给出一个具有覆盖的二分图，使得上述算法找不到最小覆盖。

参考答案第1章一、选择题1. C2. A3. C4. C A D B5. B6. B7. D 8. B 9. B 10. B 11. D 12. B二、填空题1. 输入；输出；确定性；可行性；有穷性2. 程序；有穷性3. 算法复杂度4. 时间复杂度；空间复杂度5. 正确性；简明性；高效性；最优性6. 精确算法；启发式算法7. 复杂性尽可能低的算法；其中复杂性最低者8. 最好性态；最坏性态；平均性态9. 基本运算10. 原地工作三、简答题1. 高级程序设计语言的主要好处是：（l）高级语言更接近算法语言，易学、易掌握，一般工程技术人员只需要几周时间的培训就可以胜任程序员的工作；（2）高级语言为程序员提供了结构化程序设计的环境和工具，使得设计出来的程序可读性好，可维护性强，可靠性高；（3）高级语言不依赖于机器语言，与具体的计算机硬件关系不大，因而所写出来的程序可移植性好、重用率高；（4）把复杂琐碎的事务交给编译程序，所以自动化程度高，发用周期短，程序员可以集中集中时间和精力从事更重要的创造性劳动，提高程序质量。

2. 使用抽象数据类型带给算法设计的好处主要有：（1）算法顶层设计与底层实现分离，使得在进行顶层设计时不考虑它所用到的数据，运算表示和实现；反过来，在表示数据和实现底层运算时，只要定义清楚抽象数据类型而不必考虑在什么场合引用它。

这样做使算法设计的复杂性降低了，条理性增强了，既有助于迅速开发出程序原型，又使开发过程少出差错，程序可靠性高。

（2）算法设计与数据结构设计隔开，允许数据结构自由选择，从中比较，优化算法效率。

（3）数据模型和该模型上的运算统一在抽象数据类型中，反映它们之间内在的互相依赖和互相制约的关系，便于空间和时间耗费的折衷，灵活地满足用户要求。

（4）由于顶层设计和底层实现局部化，在设计中出现的差错也是局部的，因而容易查找也容易纠正，在设计中常常要做的增、删、改也都是局部的，因而也都容易进行。