算法分析与设计(线下作业二)

合集下载

算法分析与设计大作业

算法分析与设计大作业摘要：本文以算法分析与设计为主题，对算法的概念、分析和设计进行了探讨。

首先介绍了算法的概念和基本特征，其次分析了算法的效率和复杂度，并介绍了常用的算法复杂度表示方法。

然后，通过实例分析了几种常用的排序算法的性能与复杂度，并对它们进行了比较。

最后，总结了算法分析与设计的重要性，并提出了进一步研究的方向。

一、引言随着计算机技术的快速发展，算法分析与设计成为计算机领域中的重要研究方向。

算法是指解决特定问题的具体步骤和方法，是计算机科学的核心和基础。

算法的效率和复杂度对计算机的性能和运行时间有着直接的影响，因此算法的分析和设计非常重要。

二、算法的概念和特征算法是指在有限的时间内解决特定问题的一种方法。

它具有以下特征：输入、输出、确定性、有穷性和可行性。

输入是指算法接受的问题的数据或信息，输出是指算法求解得到的问题的解。

确定性是指算法在任何情况下都能够得到相同的结果。

有穷性是指算法在执行有限的步骤后能够终止。

可行性是指算法的每一步都是可行的，即能够被计算机执行。

三、算法的效率和复杂度算法的效率是指算法解决问题所需要的时间和空间资源的多少。

算法的复杂度是用来描述算法执行过程中所需要的资源的多少。

常用的算法复杂度表示方法有时间复杂度和空间复杂度。

时间复杂度表示算法的执行时间与输入规模之间的关系，用大写O表示。

空间复杂度表示算法所需的空间资源与输入规模之间的关系，用大写S表示。

四、常用的排序算法及性能与复杂度分析1.插入排序插入排序是一种简单直观的排序算法。

它的基本思想是将未排序的元素逐个插入到已排序的序列中。

插入的过程中，需要比较和移动元素的次数与未排序序列中的元素个数相关，因此时间复杂度为O(n^2)。

空间复杂度为O(1)。

2.冒泡排序冒泡排序是一种重复比较相邻元素并交换位置的排序算法。

它的基本思想是两两比较相邻元素，如果顺序错误则交换位置。

冒泡的过程中，需要进行n-1次的比较和交换操作，因此时间复杂度为O(n^2)。

算法分析与设计（线下作业二）

算法分析与设计（线下作业⼆）《算法分析与设计》学习中⼼：专业：学号：姓名：作业练习⼆⼀、名词解释1、MST性质2、⼦问题的重叠性质递归算法求解问题时，每次产⽣的⼦问题并不总是新问题，有些⼦问题被反复计算多次，这种性质称为⼦问题的重叠性质。

⼆、简答题1、简述动态规划算法求解的基本要素。

答：动态规划算法求解的基本要素包括：1)最优⼦结构是问题能⽤动态规划算法求解的前提；2)动态规划算法，对每⼀个⼦问题只解⼀次，⽽后将其解保存在⼀个表格中，当再次需要解此⼦问题时，只是简单地⽤常数时间查看⼀下结果，即重叠⼦问题。

2、备忘录⽅法和动态规划算法相⽐有何异同简述之。

答：备忘录⽅法是动态规划算法的变形。

与动态规划算法⼀样，备忘录⽅法⽤表格保存已解决的⼦问题的答案，在下次需要解此问题时，只要简单地查看该⼦问题的解答，⽽不必重新计算。

备忘录⽅法与动态规划算法不同的是，备忘录⽅法的递归⽅式是⾃顶向下的，⽽动态规划算法则是⾃底向上递归的。

因此，备忘录⽅法的控制结构与直接递归⽅法的控制结构相同，区别在于备忘录⽅法为每个解过的⼦问题建⽴了备忘录以备需要时查看，避免了相同的⼦问题的重复求解，⽽直接递归⽅法没有此功能。

3、贪⼼算法求解的问题主要具有哪些性质简述之。

答：贪⼼算法求解的问题⼀般具有⼆个重要的性质：⼀是贪⼼选择性质，这是贪⼼算法可⾏的第⼀个基本要素；另⼀个是最优⼦结构性质，问题的最优⼦结构性质是该问题可⽤贪⼼算法求解的关键特征。

三、算法编写及算法应⽤分析题1、设计求解如下最⼤⼦段和问题的动态规划算法。

只需给出其递推计算公式即可。

最⼤⼦段和问题：给定由n 个整数（可能为负整数）组成的序列a1a2 … an，求该序列形如Σi≤k≤j ak的⼦段和的最⼤值。

当所有整数均为负整数时定义其最⼤⼦段和为0。

依次定义，所求的最优值为max{0, max1≤i≤j≤n Σi≤k≤j ak }。

2、关于多段图问题。

设G ＝(V ，E)是⼀个赋权有向图，其顶点集V 被划分成k>2个不相交的⼦集V i ：1i k ≤≤，其中，V 1和V k 分别只有⼀个顶点s （称为源）和⼀个顶点t （称为汇），图中所有的边（u,v ），i u V ∈，1i v V +∈。

算法分析与设计作业及参考答案样本

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

第一部分为”客观题部分”, 由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、请写出批处理作业调度的回溯算法。

《算法分析与设计》期末试题及参考答案

《算法分析与设计》期末试题及参考答案一、简要回答下列问题：1.算法重要特性是什么？2.算法分析的目的是什么？3.算法的时间复杂性与问题的什么因素相关？4.算法的渐进时间复杂性的含义？5.最坏情况下的时间复杂性和平均时间复杂性有什么不同？6.简述二分检索（折半查找）算法的基本过程。

7.背包问题的目标函数和贪心算法最优化量度相同吗？8.采用回溯法求解的问题，其解如何表示？有什么规定？9.回溯法的搜索特点是什么？10.n皇后问题回溯算法的判别函数place的基本流程是什么？11.为什么用分治法设计的算法一般有递归调用？12.为什么要分析最坏情况下的算法时间复杂性？13.简述渐进时间复杂性上界的定义。

14.二分检索算法最多的比较次数？15.快速排序算法最坏情况下需要多少次比较运算？16.贪心算法的基本思想？17.回溯法的解（x1,x2,……x n）的隐约束一般指什么？18.阐述归并排序的分治思路。

19.快速排序的基本思想是什么。

20.什么是直接递归和间接递归？消除递归一般要用到什么数据结构？21.什么是哈密顿环问题？22.用回溯法求解哈密顿环，如何定义判定函数？23.请写出prim算法的基本思想。

二、复杂性分析1、MERGESORT(low，high)if low<high；then mid←(low，high)/2；MERGESORT(low，mid)；MERGESORT(mid+1，high)；MERGE(low，mid，high)；endifend MERGESORT2、procedure S1(P，W，M，X，n)i←1; a←0while i≤ n doif W(i)>M then return endifa←a+ii←i+1 ;repeatend3.procedure PARTITION(m,p)Integer m,p,i;global A(m:p-1)v←A(m);i←mlooploop i←i+1 until A(i) ≥v repeatloop p←p-1 until A(p) ≤v repeatif i<pthen call INTERCHANGE(A(i),A(p))else exitendifrepeatA(m) ←A(p);A(p) ←vEnd PARTITION4.procedure F1(n)if n<2 then return(1)else return(F2(2,n,1,1))endifend F1procedure F2(i,n,x,y)if i≤nthen call F2(i+1,n,y,x+y)endifreturn(y)end F25.procedure MAX(A,n,j)xmax←A(1);j←1for i←2 to n doif A(i)>xmax then xmax←A(i); j←i;endif repeatend MAX6.procedure BINSRCH(A,n,x,j)integer low,high,mid,j,n;low←1;high←nwhile low≤high domid←|_(low+high)/2_|case:x<A(mid):high←mid-1:x>A(mid):low←mid+1:else:j ←mid; returnendcase repeat j ←0 end BINSRCH三、算法理解1、写出多段图最短路经动态规划算法求解下列实例的过程，并求出最优值。

东北师范大学2020年5月课程考试（网考）《算法分析与设计》参考答案题库汇总奥鹏

东北师范大学2020年5月课程考试（网考）《算法分析与设计》参考答案题库汇总奥鹏最新东北师范大学《算法分析与设计》网考参考试题汇总标准答案1.陈述算法在最坏情况下的时间复杂度和平均时间复杂度；这两种评估算法复杂性的方法各自有什么实际意义？答最坏情况下的时间复杂度称最坏时间复杂度。

一般不特别说明，讨论的时间复杂度均是最坏情况下的时间复杂度。

这样做的原因是：最坏情况下的时间复杂度是算法在任何输入实例上运行时间的上界，这就保证了算法的运行时间不会比任何更长。

平均时间复杂度是指所有可能的输入实例均以等概率出现的情况下，算法的期望运行时间。

1. 简单选择排序算法在最好情况下的时间复杂度为O（N）。

A. 错误B. 正确【答案】A2. 若需在O(nlog2n)的时间内完成对数组的排序，且要求排序是稳定的，则可选择的排序方法是()。

A. 快速排序B. 堆排序C. 归并排序D. 直接插入排序【答案】C3. 求n的阶乘的表示方法n!=n*(n-1)! ，其中0!=1，对应的是递归的思想。

A. 错误B. 正确【答案】B4. 一个算法的评价只要考虑时间复杂度。

A. 错误B. 正确【答案】A5. 十进制的123，1的位权是（）。

A. 1B. 2C. 10D. 100【答案】D6. 栈和队列都是线性结构。

A. 错误B. 正确【答案】B7. 高精度计算时可以用数组来存储运算结果。

A. 错误B. 正确【答案】B8. 下列叙述中正确的是（）A. 数据的逻辑结构与存储结构必定是一一对应的B. 由于计算机在存储空间上是向量式的存储结构，因此，利用数组只能处理线性结构C. 程序设计语言中的数组一般是顺序存储结构，因此，利用数组只能处理线性结构D. 以上说法都不对【答案】D9. 按F5开始调试，程序便会直接运行到断点处。

接下来可以逐行来运行程序，查看各个变量的值，也可以直接运行到下一个断点或程序结束，这样过程被称作()。

A. 设置断点B. 单步调试C. 程序编译D. 程序调试【答案】B。

算法设计与分析2

由复此杂可度T得分(：n析) TC(CCn7112)T11=1(OnCC(/n12O2223))A(1)1O1没AAB12(11有n121改)AA122进2nnBBA12221112
B12
B22
B21
C12 A11 B12 A12 B22
C21 A21 B11 A22 B21
C22 A21 B12 A22 B22
M 4 A22 (B21 B11 )
M 5 ( A11 A22 )( B11 B22 )
M 6 ( A12 A22 )( B21 B22 )
M 7 ( A11 A21 )( B11 B12 )
A12 B11 B12
A22 B21
B22
C11 M 5 M 4 M 2 M 6 C12 M1 M 2 C21 M 3 M 4 C22 M 5 M1 M 3 M 7
分治法解决问题的步骤
➢ 利用分治法求解问题的算法通常包含如下几个步骤：
✓ ① 分解(Divide) 将原问题分解为若干个相互独立、规模较小且与原问题形式相同的一系列子问题。
原问题应该分为多少个子问题才较适宜？各个子问题的规模应该怎样才为适当？这些问题很难存在一个统一的答案。实践证明，在用分治法设计算法时，最好使各子问题的规模大致相同。
若依此定义来计算A和B的乘积矩阵C，则每计算C的一个元素C[i][j]，需要做n次乘法和n-1次加法。因此，算出矩阵C的个元素所需的计算时间为O(n3)
Strassen矩阵乘法
➢ 算法实现：
✓ 传统方法：算法的时间复杂度 T N O N3
✓ 分治法:
将矩阵A，B和C中每一矩阵都分块成4个大小相等的子矩阵。由此可将方程C=AB重写为：
a11 a12

《算法分析与设计》课后作业

《算法分析与设计》各章课后作业第一章课后作业1. 设某算法在输入规模为n 时的计算时间为T(n)=10*2n。

若在甲台计算机上实现并完成该算法的时间为t 秒，现有一台运行速度是甲的64倍的另一台计算机乙，问在乙计算机上用同一算法在t 秒内能解决的问题的规模是多大？2.按照渐近阶从低到高的顺序排列以下表达式：4n 2，logn ，3n，20n ，2，n 2/3。

又n!应该排在哪一位？第二章课后作业1. 用展开法求解下列递推关系：T(n)=⎩⎨⎧>+=1n )()2/(20n )1(n O n T O，写出T(n)的大O 记号表示。

2. 下面是实现在a[0]<=a[1]<=…<=a[n-1]中搜索x 的二分搜索算法，请根据二分搜索技术在下划线处填充语句。

算法描述如下： template<class Type>public static int BinarySearch(int []a, int x, int n) { //在a[0]<=a[1]<=…<=a[n-1]中搜索 x // 找到x 时返回其在数组中的位置，否则返回-1 int left = 0; int right = n - 1; while ( ) {int middle = ;if(x == a[middle]) return ; if(x > a[middle]) left = middle + 1; else right= ; }return -1; // 未找到x}第三章课后作业1、选择题。

（1）下列算法中通常以自底向上的方式求解最优解的是（）。

A、备忘录法B、动态规划法C、贪心法D、回溯法（2）备忘录方法是那种算法的变形。

（）A、分治法B、动态规划法C、贪心法D、回溯法（3）矩阵连乘问题的算法可由（）设计实现。

A、分支界限算法B、动态规划算法C、贪心算法D、回溯算法2．计算题。

算法分析与设计_山东财经大学中国大学mooc课后章节答案期末考试题库2023年

算法分析与设计_山东财经大学中国大学mooc课后章节答案期末考试题库2023年1.蒙特卡罗算法的结果未必正确，并且可能难以有效判定是否正确。

答案:正确2.T(n) = T(n-1) + 1， T(1)=1，则 T(n) =Q（___）答案:n3.木板问题：农夫约翰为了修理栅栏，将一块木板切割成N块，N块的长度和=原木板长度。

每次切割木板时的开销为该木板的长度。

木板长15，切成长为1、 2 、3 、 4 、5的木板。

如何切割，使开销最小？ (1) 该问题最好使用（）算法求解。

A 枚举B 贪心C 分治D 递推(2)第一次切割成长度为_____和_____的两块。

(3) 切割的策略和_____算法相同。

A MSTB 区间调度C 哈夫曼D 区间划分答案:B;6;9;C4.背包问题，背包容量C=20 ，物品价值p =[4, 8，15, 1, 6，3], 物品重量w=[5, 3，2, 10, 4, 8]，如果是0-1背包问题，求装入背包的最大价值和相应装入物品。

(1)该问题最好使用（）算法求解？A 动态规划算法B 贪心算法C 枚举算法D 分治算法(2)装入背包的最大价值是_____,(3)最大价值对应的物品编号为____、____、____、____。

（从小到大）答案:A;33;1;2;3;55.动态规划方程M[i]=min(M[j]+wij), 1≤i≤j≤n, 则算法的时间复杂度为n^2答案:正确6.给定二分图G = 中无孤立点，|V|=n，其最大流算法求得最大流f, 则 G的最大独立数=n-f答案:正确7.旅行商问题的所有解，可以组织成一棵树，包含了所有城市的排列组合。

树的根结点到任一叶结点的路径，定义了图的一条周游路线。

答案:正确8.对于问题的一个实例，解向量满足显式约束条件的所有多元组，构成了该实例的一个解空间。

答案:正确9.Floyd算法是动态规划算法，稠密图效果最佳，边权可正可负。

答案:正确10.f=o(g)当且仅当g = ω (f)答案:正确11.预流推进算法的关键操作有（）答案:重标号_初始化_推进12.最小费用最大流算法求得解需满足（）条件。

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

算法分析与设计作业及参考答案作业题目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)。

算法分析与设计（李清勇）课后习题答案

算法分析与设计（李清勇）课后习题答案5-1凸多边形最优三⾓剖分问题//3d5 凸多边形最优三⾓剖分#include "stdafx.h"#includeusing namespace std;constint N = 7;//凸多边形边数+1int weight[][N] = {{0,2,2,3,1,4},{2,0,1,5,2,3},{2,1,0,2,1,4},{3,5,2,0,6,2},{1,2,1,6,0,1},{4,3,4,2,1,0}};//凸多边形的权intMinWeightTriangulation(intn,int **t,int **s);void Traceback(inti,intj,int **s);//构造最优解int Weight(inta,intb,int c);//权函数int main(){int **s = new int *[N];int **t = new int *[N];for(inti=0;is[i] = new int[N];t[i] = new int[N];}cout<<"此多边形的最优三⾓剖分值为："<cout<<"最优三⾓剖分结构为："<Traceback(1,5,s); //s[i][j]记录了Vi-1和Vj构成三⾓形的第3个顶点的位置return 0;}intMinWeightTriangulation(intn,int **t,int **s){for(inti=1; i<=n; i++){t[i][i] = 0;}for(int r=2; r<=n; r++) //r为当前计算的链长（⼦问题规模）{for(inti=1; i<=n-r+1; i++)//n-r+1为最后⼀个r链的前边界{int j = i+r-1;//计算前边界为r，链长为r的链的后边界t[i][j] = t[i+1][j] + Weight(i-1,i,j);//将链ij划分为A(i) * ( A[i+1:j] )这⾥实际上就是k=i s[i][j] = i; for(int k=i+1; k//将链ij划分为( A[i:k] )* (A[k+1:j])int u = t[i][k] + t[k+1][j] + Weight(i-1,k,j);if(ut[i][j] = u;s[i][j] = k;}}}}return t[1][N-2];}voidTraceback(inti,intj,int **s){if(i==j) return;Traceback(i,s[i][j],s);Traceback(s[i][j]+1,j,s);cout<<"三⾓剖分顶点：V"<int Weight(inta,intb,int c){return weight[a][b] + weight[b][c] + weight[a][c];}5-4 数字三⾓形最短路径5-2 游艇租赁问题#includeusing namespace std;#define N 210int cost[N][N];int m[N];int main(){intn,i,j;while(cin>>n){for(i=1;ifor(j=i+1;j<=n;j++)cin>>cost[i][j];m[1]=0;int min;for(i=2;i<=n;i++){min=cost[1][i];for(j=1;j<=i-1;j++){if(cost[j][i]!=0 && m[j]+cost[j][i]min=m[j]+cost[j][i];}m[i]=min;}cout<}return 0;}5-6 合唱队形问题#include/doc/d0aa713f51e79b8969022686.html ing namespace std; 2.3.//⽤于保存⼦问题最优解的备忘录4.typedef struct5.{6.int maxlen; //当前⼦问题最优解7.int prev; //构造该⼦问题所⽤到的下⼀级⼦问题序号(⽤于跟踪输出最优队列)8.}Memo;9.10.//⽤于递归输出Memo B中的解11.void Display(int* A, Memo* M, int i)12.{13.if (M[i].prev == -1)14. {15. cout<16.return;17. }18. Display(A, M, M[i].prev);19. cout<20.}21.22.//算法主要部分23.void GetBestQuence(int* A, int n)24.{25.//定义备忘录并作必要的初始化26. Memo *B = new Memo[n]; //B[i]代表从A[0]到A[i]满⾜升序剔除部分元素后能得到的最多元素个数27. Memo *C = new Memo[n]; //C[i]代表从A[i]到A[n-1]满⾜降序剔除部分元素后能得到的最多元素个数28. B[0].maxlen = 1; //由于B[i]由前向后构造初始化最前⾯的⼦问题 (元素本⾝就是⼀个满⾜升序降序的序列)29. C[n-1].maxlen = 1; //同样C[i]由后向前构造30.for (int i=0; i31.//⽤于在跟踪路径时终⽌递归或迭代(因为我们并不知道最终队列从哪⾥开始)32. {33. B[i].prev = -1;34. C[i].prev = -1;35. }36.37.for (i=1; i38. {39.int max=1;40.for (int j=i-1; j>=0; j--) //查看前⾯的⼦问题找出满⾜条件的最优解并且记录41. {42.if (A[j]max)43. {44. max = B[j].maxlen+1; //跟踪当前最优解45. B[i].prev = j; //跟踪构造路径46. }47. }48. B[i].maxlen = max; //构造最优解49. }50.51.for (i=n-1; i>0; i--)52. {53.int max=1;54.for (int j=i; j解时可以直接⽤B[i]+C[i]-155.//否则我们得到的最优解始终为B[n-1]+C[n-1]56. {57.if (A[j]max) //⽐当前长度更长记录并构造58. {59. max = C[j].maxlen+1;60. C[i].prev = j;61. }62. }63. C[i].maxlen = max;64. }65.66.//遍历i 得到最⼤的B[i]+C[i]-1(-1是因为我们在B[i]和C[i]中均加上了A[i]这个数因此需要减去重复的)67.int maxQuence = 0; //记录当前最优解68.int MostTall; //记录i ⽤于跟踪构造路径69.for (i=0; i70. {71.if (B[i].maxlen+C[i].maxlen-1 > maxQuence)72. {73. maxQuence = B[i].maxlen+C[i].maxlen-1;74. MostTall = i;75. }76. }77.78. cout<<"最⼤合唱队形长度: "<79.80.//B由前向后构造因此prev指向前⾯的元素需要递归输出81. Display( A, B, MostTall);82.//C的prev指向后⾯元素直接迭代输出83.while (C[MostTall].prev != -1)84. {85. MostTall = C[MostTall].prev;86. cout<87. }88. cout<89.90.delete []B;91.delete []C;92.}93.int main()94.{95.//测试96.int *A;97.int n;98. cout<<"请输⼊合唱队员个数: "<99. cin>>n;100.101. A = new int[n];102. cout<<"输⼊队员⾝⾼ :"<103.for (int i=0; i104. {105. cin>>A[i];106. }107. GetBestQuence(A, n);108.delete []A;109.return 0;110.}5-7买票问题状态转移⽅程是f[i] := min(f[i - 1] + t[i], f[i - 2] + r[i - 1]); {i = 2 ~ n} 初值f[0] := 0; f[1] := t[1]; constmaxn = 1000;vari, j, n : longint;f, t, r : array[0..maxn] of longint;function min(a, b : longint) : longint;begin if a < b then exit(a); exit(b); end;beginreadln(n);for i := 1 to n do read(t[i]);for i := 1 to n - 1 do read(r[i]);f[0] := 0; f[1] := t[1];for i := 2 to n dof[i] := min(f[i - 1] + t[i], f[i - 2] + r[i - 1]);writeln(f[n]);end.伪代码BuyTicks(T, R)1n ← length[T]2f[0] ← 03f[1] ← T[1]4for i ← 2to n do5f[i] ← f[i-2]+R[i-1]6if f[i] > f[i-1]+T[i] then7f[i] ← f[i-1]+T[i]8return f5-8最⼤⼦段和问题#include#includeintmax_sum(intn,int *a,int *besti,int *bestj){ int *b = (int *)malloc(n * sizeof(int));int sum = 0;int i = -1;int temp = 0;for (i=0;i<=n-1;i++) {if (temp > 0)temp += a[i];elsetemp = a[i];b[i] = temp;}sum = b[0];for (i=1;i<=n-1;i++) {if (sum < b[i]) {sum = b[i];*bestj = i;}}for (i = *bestj;i>= 0;i--) {if (b[i] == a[i]) {*besti = i;break;}}free(b);return sum;}int main(void){int a[] = {-2,1,-4,13,-5,-2,-10,20,100};int length = sizeof(a)/sizeof(int);intbesti = -1;intbestj = -1;sum = max_sum(length,a,&besti,&bestj);printf("besti = %d,bestj = %d,max_sum=%d\n",besti,bestj,sum); return 0;}5-9 装箱问题发现就是0-1背包问题每个物品的体积就是花费同时也是价值，也就是说这题可以转化为在总体积为w下，可以得到最⼤的价值最后⽤总体积减去最⼤的价值就是剩下最少的空间状态转移⽅程d[j] = max(d[j], d[j - a[i]] + a[i]);第⼆⾏为⼀个整数，表⽰有n个物品；接下来n⾏，每⾏⼀个整数表⽰这n个物品的各⾃体积。

黄宇《算法设计与分析》课后习题解析(二)精选全文

黄宇《算法设计与分析》课后习题解析（⼆）第2章：从算法的视⾓重新审视数学的概念2.1：(向下取整)题⽬：请计算满⾜下⾯两个条件的实数的区间解析：根据向下取整的含义，令，讨论a的取值范围即可解答：令，则可得：即：故的取值区间为：2.2: (取整函数)题⽬：证明：对于任意整数,（提⽰：将n划分为）。

解析：根据提⽰将n进⾏划分，根据取整函数的定义⽤k表⽰取整函数，即可证明；证明如下：因为对于任意整数,可划分为，则:① ；② ；综上：对于任意整数,, 得证；2.3: (斐波拉契数列)对于斐波拉契数列，请证明：1）题⽬：是偶数当且仅当n能被3整除解析：由斐波拉契数列的递归定义式，容易联想到数学归纳法；证明如下：（采⽤数学归纳法）i)当n = 1,2,3时，依次为1，1，2，符合命题；ii)假设当（k>=1）时命题均成⽴，则：① 当n = 3k+1时，是奇数，成⽴；② 当n = 3k+2时，是奇数，成⽴；③ 当 n = 3(k+1)时，是偶数，成⽴；综上：归纳可得为偶数当且仅当，得证;2）题⽬：x x =1+a (0<a <1)x =1+a (0<a <1)⌊x ⌋=1⇒⌊x ⌋=21⌊x ⌋=2⌊1+a +22a ⌋=1a +22a <1⇒0<a <−21⇒1<a +1<⇒21<x <2x (1，)2n ≥1⌈log (n +1)⌉=⌊logn ⌋+12≤k n ≤2−k +11n ≥12≤k n ≤2−k +11k +1=⌈log (2+k 1)⌉≤⌈log (n +1)⌉≤⌈log (2)⌉=k +1k +1=>⌈log (n +1)⌉=k +1k =⌊log (2)⌋≤k ⌊logn ⌋≤⌊log (2−k +11)⌋=k =>⌊logn ⌋=k n ≥1⌈log (n +1)⌉=k +1=⌊logn ⌋+1F n F n n ≤3k F =n F +n −1F =n −2F +3k F =3k −1>F 3k +1F =n F +3k +1F =3k >F 3k +2F =n F +3k +2F =3k +1>F 3k +3F n 3∣n F −n 2F F =n +1n −1(−1)n +1解析：同1）理，容易联想到数学归纳法证明如下：（采⽤数学归纳法）i)当n = 2时，, 易知成⽴；ii)假设当 n = k 时命题成⽴，① 若k = 2m, 则,当n = k+1 = 2m+1时，要证命题成⽴，即证： => ,代⼊递推式, 得：, 易知是恒等式，故命题成⽴；②当 k=2m+1时，同①理可证命题成⽴；综上：归纳可得，得证；2.4：(完美⼆叉树)给定⼀棵完美⼆叉树，记其节点数为，⾼度为，叶节点数为，内部节点数为1）题⽬：给定上述4个量中的任意⼀个，请推导出其他3个量解析：根据完美⼆叉树的结构特点易得解答：（仅以已知⾼度h推导其他三个量为例，其余同理）已知⾼度为h，可得：节点数：叶节点数：内部节点数：2）题⽬：请计算完美⼆叉树任意⼀层的节点个数：① 如果任意指定深度为的⼀层节点，请计算该层节点个数；② 如果任意指定⾼度为的⼀层节点，请计算该层节点个数；解析：根据完美⼆叉树的结构特点易得（注意节点深度和节点⾼度是互补的，相加为树⾼）解答：① ; ② ;2.5: (⼆叉树的性质)对于⼀棵⾮空的⼆叉树T，记其中叶节点的个数为，有1个⼦节点的节点个数为，有两个⼦节点的节点个数为1）题⽬：如果T是⼀棵2-tree，请证明。

算法分析与设计(答案)

算法分析与设计（答案）一：二分查找的递归实现算法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);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函数的递归实现算法import java.util.Scanner;public class Test2 {private static int akm(int n, int m) {// 递归设计int r, g;if (n == 1 && m == 0)r = 2;else if (n == 0 && m >= 0)r = 1;else if (m == 1)r = n * 2;else if (m == 2)r = (int) Math.pow(2, n);else if (m == 0 && n >= 2)r = n + 2;else {g = akm(n-1, m);r = akm(g, m-1);// 两次连着递归}return r;}public static void main(String[] args) {try {System.out.println("请输入1个大于等于0的整数：");Scanner sc = new Scanner(System.in);int n = sc.nextInt();System.out.println("请再输入1个大于等于0的整数：");int m = sc.nextInt();System.out.println(akm(n, m));} catch (Exception e) {}}}三：全排列的递归实现算法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) ;}}六：合并排序的递归实现算法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]+" ");}}。

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

【关键字】分析《算法分析与设计》作业参考答案作业一一、名词解释：1.递归算法：直接或间接地调用自身的算法称为递归算法。

2.程序：程序是算法用某种程序设计语言的具体实现。

2、简答题：1.算法需要满足哪些性质？简述之。

算法是若干指令的有穷序列，满足性质：1）输入：有零个或多个外部量作为算法的输入。

2）输出：算法产生至少一个量作为输出。

3）确定性：组成算法的每条指令清晰、无歧义。

4）有限性：算法中每条指令的执行次数有限，执行每条指令的时间也有限。

2.简要分析分治法能解决的问题具有的特征。

分析分治法能解决的问题主要具有如下特征：1）该问题的规模缩小到一定的程度就可以容易地解决；2）该问题可以分解为若干个规模较小的相同问题，即该问题具有最优子结构性质；3）利用该问题分解出的子问题的解可以合并为该问题的解；4）该问题所分解出的各个子问题是相互独立的，即子问题之间不包含公共的子问题。

3.简要分析在递归算法中消除递归调用，将递归算法转化为非递归算法的方法。

将递归算法转化为非递归算法的方法主要有：1）采用一个用户定义的栈来模拟系统的递归调用工作栈。

该方法通用性强，但本质上还是递归，只不过人工做了本来由编译器做的事情，优化效果不明显。

2）用递推来实现递归函数。

3）通过Cooper变换、反演变换能将一些递归转化为尾递归，从而迭代求出结果。

后两种方法在时空复杂度上均有较大改善，但其适用范围有限。

三、算法编写及算法应用分析题：1.冒泡排序算法的基本运算如下：for i ←1 to n-1 dofor j ←1 to n-i doif a[j]<a[j+1] then交换a[j]、a[j+1]；分析该算法的时间复杂性。

解答：排序算法的基本运算步为元素比较，冒泡排序算法的时间复杂性就是求比较次数与n的关系。

1）设比较一次花时间1；2）内循环次数为：n-i次,（i=1,…n），花时间为：3）外循环次数为：n-1，花时间为：2.设计一个分治算法计算一棵二叉树的高度。

算法分析与设计(习题答案)

算法分析与设计教程习题解答第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．解：算法略。

算法设计与分析(第2版) 王红梅胡明习题参考答案

#include<iostream>
usingnamespacestd;
intmain()
{
longdoubleresult=1;
doublej=1;
for(inti=1;i<=64;++i)
{
j=j*2;
result+=j;
j++;
}
cout<<result<<endl;
return0;
}
习题3
1．假设在文本"ababcabccabccacbab"中查找模式"abccac"，写出分别采用BF算法和KMP算法的串匹配过
else
value=a[i+2]-a[i+1];
}
cout<<value<<endl;
return0;
}
4．设数组a[n]中的元素均不相等，设计算法找出a[n]中一个既不是最大也不是最小的元素，并说明最坏情况下的比较次数。要求分别给出伪代码和C++描述。
#include<iostream>
usingnamespacestd;
{
if(n==1)
return4;
elseif(n>1)
return3*T(n-1);
}
(2)
intT(intn)
{
if(n==1)
return1;
elseif(n>1)
return2*T(n/3)+n;
}
5.求下列问题的平凡下界，并指出其下界是否紧密。
（1）求数组中的最大元素；
（2）判断邻接矩阵表示的无向图是不是完全图；

算法设计与分析第2版王红梅胡明习题答案

算法设计与分析第2版王红梅胡明习题答案精品文档习题胡明-版)-王红梅-算法设计与分析(第2答案1习题）—1783Leonhard Euler，17071.图论诞生于七桥问题。

出生于瑞士的伟大数学家欧拉（提出并解决了该问题。

七桥问题是这样描述的：北区一个人是否能在一次步行中穿越哥尼斯堡（现东区在叫加里宁格勒，在波罗的海南岸）城中全部岛区的七座桥后回到起点，且每座桥只经过一次，南区是这条河以及河上的两个岛和七座桥的图1.7 1.7 七桥问题图草图。

请将该问题的数据模型抽象出来，并判断此问题是否有解。

七桥问题属于一笔画问题。

输入：一个起点输出：相同的点一次步行1，经过七座桥，且每次只经历过一次2，回到起点3，该问题无解：能一笔画的图形只有两类：一类是所有的点都是偶点。

另一类是只有二个奇点的图形。

）用的不是除法而是减最初的欧几里德算法2．在欧几里德提出的欧几里德算法中（即法。

请用伪代码描述这个版本的欧几里德算法1.r=m-nr=0 循环直到2.m=n 2.1n=r 2.2r=m-n 2.3m输出3．设计算法求数组中相差最小的两个元素（称为最接近数）的差。

要求分别给出伪代3++描述。

C码和采用分治法// //对数组先进行快速排序在依次比较相邻的差//精品文档．精品文档#includeusing namespace std;int partions(int b[],int low,int high){int prvotkey=b[low];b[0]=b[low];while (low<high)< p="">{while (low<high&&b[high]>=prvotkey)</high&&b[high]> --high;b[low]=b[high];while (low<high&&b[low]<=prvotkey)< p="">++low;b[high]=b[low];}b[low]=b[0];return low;}void qsort(int l[],int low,int high){int prvotloc;if(low<high)< p="">{prvotloc=partions(l,low,high); //将第一次排序的结果作为枢轴qsort(l,low,prvotloc-1); //递归调用排序由low 到prvotloc-1 qsort(l,prvotloc+1,high); //递归调用排序由 prvotloc+1到 high }}void quicksort(int l[],int n){qsort(l,1,n); //第一个作为枢轴，从第一个排到第n个}int main(){int a[11]={0,2,32,43,23,45,36,57,14,27,39};int value=0;//将最小差的值赋值给valuefor (int b=1;b<11;b++)cout<<a[b]<<' ';<="" p="">精品文档．精品文档cout<<endl;< p="">quicksort(a,11);for(int i=0;i!=9;++i){if( (a[i+1]-a[i])<=(a[i+2]-a[i+1]) )value=a[i+1]-a[i];elsevalue=a[i+2]-a[i+1];}cout<<value<<endl;< p="">return 0;}4．设数组a[n]中的元素均不相等，设计算法找出a[n]中一个既不是最大也不是最小的元素，并说明最坏情况下的比较次数。

北大屈婉玲算法分析与设计习题解答2

101i 的个数仓储问题作业二1.x i ＝0,1是货柜i 的个数，仓储问题：max nx l 1∑∑=n ii i 令C [k ,y ]是只允许装前k 个货柜，库房长度为y 时的最大收益1,0,1=≤=i i i ix L x l 1],1[],[k L l y y k C y k C k ⎨⎧>−−−<−=1],1[}],1[],,1[max{l y C l y l l y k C y k C kk k =⎩≥≥+1伪码略.W (n )=O (nD )33. 作业调度与01背包问题类似使用动态规划方法0-1背包问题类似，使用动态规划方法. 令N j (d )表示对作业集{1,2,…,j }，结束时间为d 的最优调度的效益那么效益，那么)(}))((),(max{)(11≥+−=−−j t d v j t d N d N d N j j j j 1)()()(1⎧≤<=−dt v j t d d N d N j j 0)1(0)()(11>⎩⎨>=d d t d N 自底向上计算，存储使用备忘录。

可以使用标记函数B (j )记录使得N j (d )达到最大是否N j (d )=N j −1(d ). 如果不等，B (j )=1，0.3否则为0.时间W (n )=O (nD )输入：加工时间伪码Job(t ,v ,D )t [1..n ]，效益v [1..n ]，结束时间D 输出：最优效益N [n,D ],标记函数B ，解是{k | B [k ]=1}1.for 1to −1. for d ←1 to t [1]12. N [1,d ]←0, B [1] ←03. for d ←t [1] to D4. N [1,d ]←v [1], B [1]←15. for k ←2 to n6for 1to 6. for d ←1 to D7. N [k ,d ]←N [k −1,d ]8.8. B [k ]←09. if d ≥t [k ] and N [k −1,d −t [k ]]+v [k ]>N [k −1,d ]10. then N [k ,d ]←N [k −1,d −t [k ]]+v [k ]411. B [k ]←14014. 双约束0-1背包问题种物品背包重量限制为m [i ,j ,k ]表示使用前i 种物品，背包重量限制为j ,容积为k 时的最大价值+−−−−=}],,1[],,,1[max{],,[v c k w j i m k j i m k j i m i i i <<−=≥≥or ],,1[],,[and c k w k i m k i m c k w j i i⎨⎧≥≥=111and ],,1[c k w j v k j m j j j i i ⎩<<11or 0c k w j 5W (n )= O (nWV )55.合并数组问题0n-1i j k k+110i jn -16递推公式X {合并问题含有整数个数⎧={x 0,x 1,…, x n －1}，X ij 表示{x i ,…,x j }合并问题，含有整数个数是n ij ，完成这些合并所需要最少的比较次数记作m [i ,j ]⎪⎪<+++∑=<≤j i a j k m k i m j i l l j k i ]},1[],[{max ⎪⎪⎨>++++=∑∑=−=−≤≤j i a a j n k m k i m j i m j l n l n k i 11]},mod )1[(],[{max ],[⎩<≤l i l jk 00m [i,i ]= 0i=0,2,…,n -1]}mod )1(,[{max 10n n i i m m n i −+=−≤≤7T (n )=O (n 3)标记函数s [i ,j ]记录使m [i ,j ] 取得最小值的k。

算法设计与分析课后习题

算法设计与分析课后习题(总8页)--本页仅作为文档封面，使用时请直接删除即可----内页可以根据需求调整合适字体及大小--第一章1. 算法分析题算法分析题1－1 求下列函数的渐进表达式(1). 3n^2 + 10n < 3n^2 + 10n^2 = 13n^2 = O(n^2)(2). n^2 / 10 + 2^n当n>5是，n^2 < 2 ^n所以，当n >= 1时，n^2/10 < 2 ^n故: n^2/10 + 2^n < 2 ^n + 2^n = 2*2^n = O(2^n)(3). 21 + 1/n < 21 + 1 = 22 = O(1)(4). log(n^3)=3log(n)=O(log(n))(5). 10log(3^n) = (10log3)n = O(n)算法分析题1-6(1)因为：f(n)=log(n^2) = 2log(n); g(n) = log(n) + 5所以：f(n)=Θ(log(n)+5) =Θ(g(n))(2)因为：log(n) < √n ; f(n) = 2log(n); g(n)= √n所以：f(n) = O(g(n))(3)因为：log(n) < n; f(n) = n; g(n) = log(n^2) = 2log(n)所以；f(n) = Ω(g(n))(4)因为：f(n) = nlogn +n; g(n) = logn所以：f(n) =Ω(g(n))(5)因为: f(n) = 10; g(n) = log(10)所以:f(n) =Θ(g(n))(6)因为: f(n)=log^2(n); g(n) = log(n)所以: f(n) ==Ω(g(n))(7)因为: f(n) = 2^n < 100*2^n; g(n)=100n^2; 2^n > n ^2所以: f(n) = Ω(g(n))(8)因为：f(n) = 2^n; g(n) = 3 ^n; 2 ^n < 3 ^n所以: f(n) = O(g(n))习题1－9 证明：如果一个算法在平均情况下的计算时间复杂性为Θ(f(n)),该算法在最坏情况下所需的计算时间为Ω(f(n)).分析与解答：因此，Tmax(N) = Ω(Tavg(N)) = Ω(Θ(f(n)))=Ω(f(n)).第二章算法分析题2-3 设a[0:n-1]是已经排好序的数组。