大学算法分析与设计复习总结
算法分析与设计总结
第一章算法概述1.算法：解决问题的一种方法或过程；由若干条指令组成的有穷指令。
2.算法的性质：1)输入：有零个或多个输入2)输出：有至少一个输出3)确定性：每条指令是清晰的、无歧义的4)有限性：每条指令的执行次数和时间都是有限的3.算法与程序的区别➢程序是算法用某种程序设计语言的具体实现➢程序可以不满足算法的有限性4.算法复杂性分析1)算法的复杂性是算法运行所需要的计算机资源的量，需要时间资源的量称为时间复杂性，需要空间资源的量称为空间复杂性2)三种时间复杂性：最坏情况、最好情况、平均情况3)可操作性最好且最有实际价值的是最坏情况下的时间复杂性第二章递归与分支策略1.递归概念：直接或间接调用自身的算法2.递归函数：用函数自身给出定义的函数3.递归要素：边界条件、递归方程4.递归的应用✧汉诺塔问题void Hanuo(int n,int a,int b,int c){if(n==1) return;Hanuo(n-1,a,c,b);move(a,b)Hanuo(n-1,c,b,a);}✧全排列问题void Perm(Type list[],int k,int m){ //产生list[k,m]的所有排列if(k == m){for(int i = 0;I <= m;i++) cout<<list[i];cout<<endl;}else{for(int i = j; i<=m;i++){Swap(list[k],list[i]);Perm(list,k+1;m);Swap(list[k],list[i])}}}5.分治法的基本思想：将一个规模较大的问题分成若干个规模较小的子问题，这些子问题互相独立且与原问题相同。
6.分治法的使用条件：✓问题的规模缩小到一定程度可以容易地解决✓问题可以分解为若干个规模较小的相同问题✓利用原问题分解出的子问题的解可以合并为原问题的解✓各个子问题是相互独立的7.分治法的时间复杂度8.分治法的应用二分搜索1)时间复杂度 O(logn)2)参考算法快速排序1)快排的运行时间与划分是否对称有关2)时间复杂度O(nlogn)合并排序1)基本思想：将待排元素分成大小大致相同的两个子集合，分别对两个子集合进行排序，最总将排序好的子集合合并成所要求的排序好的集合。
算法设计与分析_总结7
第一章：算法定义: 算法是若干指令的有穷序列, 满足性质: (1)输入: 有外部提供的量作为算法的输入。
(2)输出: 算法产生至少一个量作为输出。
1. (3)确定性：组成算法的每条指令是清晰, 无歧义的。
2. (4)有限性：算法中每条指令的执行次数是有限的, 执行每条指令的时间也是有限的。
3. 程序定义: 程序是算法用某种程序设计语言的具体实现。
可以不满足算法的性质(4)。
4. 算法复杂性分为时间复杂性和空间复杂性。
5. 可操作性最好且最有使用价值的是最坏情况下的时间复杂性。
6. O(n)定义: 存在正的常数C 和自然数N0, 当N>=N0时有f(N)<=Cg(N),则称函数f(N)当N 充分大时有上界, 记作f(N)=O(g(n)). 7. Ω(n)定义: 存在正的常数C 和自然数N0, 当N>=N0时有f(N)>=Cg(N),则称函数f(N)当N 充分大时有上界, 记作f(N)=Ω(g(n)). 8. (n)定义:当f(n)=O(g(n))且f(N)=Ω(g(n)), 记作f(N)= (g(n)), 称为同阶。
求下列函数的渐进表达式: 3n2+10n ~~~O(n2) n2/10+2n~~~O(2n) 21+1/n~~~O(1) logn 3~~~O(logn) 10log3n ~~~O(n) 从低到高渐进阶排序: 2 logn n2/3 20n 4n2 3n n!第二章：1. 分治法的设计思想: 将一个难以直接解决的问题, 分割成一些规模较小的相同问题, 以便各个击破分而治之。
2. 例1 Fibonacci 数列 代码（注意边界条件）。
int fibonacci(int n) {if (n <= 1) return 1;return fibonacci(n-1)+fibonacci(n-2);}3. Ackerman 函数双递归。
A(1,1)代入求值。
A(1,1)=A(A(0,1),0)=A(1,0)=24. 全排列的递归算法代码。
算法分析与设计总结
算法分析与设计总结10008148 朱凌峰分析与设计总结算法（Algorithm）是一系列解决问题的清晰指令，也就是说，能够对一定规范的输入，在有限时间内获得所要求的输出。
如果一个算法有缺陷，或不适合于某个问题，执行这个算法将不会解决这个问题。
不同的算法可能用不同的时间、空间或效率来完成同样的任务。
一个算法的优劣可以用空间复杂度与时间复杂度来衡量。
算法可以理解为有基本运算及规定的运算顺序所构成的完整的解题步骤。
或者看成按照要求设计好的有限的确切的计算序列，并且这样的步骤和序列可以解决一类问题。
一个算法应该具有以下五个重要的特征：1、有穷性：一个算法必须保证执行有限步之后结束；2、确切性：算法的每一步骤必须有确切的定义；3、输入：一个算法有0个或多个输入，以刻画运算对象的初始情况，所谓0个输入是指算法本身定除了初始条件；4、输出：一个算法有一个或多个输出，以反映对输入数据加工后的结果。
没有输出的算法是毫无意义的；5、可行性：算法原则上能够精确地运行，而且人们用笔和纸做有限次运算后即可完成。
算法复杂度算法（Algorithm）是一系列解决问题的清晰指令，也就是说，能够对一定规范的输入，在有限时间内获得所要求的输出。
如果一个算法有缺陷，或不适合于某个问题，执行这个算法将不会解决这个问题。
不同的算法可能用不同的时间、空间或效率来完成同样的任务。
一个算法的优劣可以用空间复杂度与时间复杂度来衡量。
算法可以理解为有基本运算及规定的运算顺序所构成的完整的解题步骤。
或者看成按照要求设计好的有限的确切的计算序列，并且这样的步骤和序列可以解决一类问题。
一个算法应该具有以下五个重要的特征：1、有穷性：一个算法必须保证执行有限步之后结束；2、确切性：算法的每一步骤必须有确切的定义；3、输入：一个算法有0个或多个输入，以刻画运算对象的初始情况，所谓0个输入是指算法本身定除了初始条件；4、输出：一个算法有一个或多个输出，以反映对输入数据加工后的结果。
算法设计与分析重点总结
算法设计与分析重点总结考试题型：选择 2* 10个填空2* 10个简答 3* 4个程序分析填空 4* 4个综合（代码）8* 4个第⼀章基础知识1.算法的定义算法就是解决问题的⽅法，是解决某⼀特定问题的⼀组有穷指令的序列，是完成⼀个任务所需要的具体步骤和⽅法2.算法的特征有限性 ⼀个算法总是在执⾏了有穷步的运算之后终⽌确定性：算法的每种运算必须要有确切的定义，不能有⼆义性。
输⼊：每个算法有0个或多个输⼊。
所谓0个输⼊是指算法本⾝定出了初始条件。
输出：⼀个算法产⽣⼀个或多个输出，这些输出是同输⼊有某种特定关系的量可⾏性：算法中有待实现的运算都是基本的运算，原理上每种运算都能由⼈⽤纸和笔在有限的时间内完成。
（实数的算术运算是“不能⾏”的）3.计算过程只满⾜确定性、能⾏性、输⼊、输出四个特性但不⼀定能终⽌的⼀组规则4.算法的有穷性意味着不是所有的计算机程序都是算法5.算法正确性证明数学归纳法，反例：能够使算法运⾏失败的输⼊实例6.算法的好坏：通过数学⽅法进⾏分析，时间复杂度，空间复杂度，循环次数（归并，快排，贪⼼的复杂度）7.算法运⾏中主要影响运⾏时间的语句是基本操作，即占有最多⽐例的语句8.时间复杂度分析：1）确定⽤来表⽰问题规模的变量；2）确定算法的基本操作；3）写出基本操作执⾏次数的函数（运⾏时间函数）；4）如果函数依赖输⼊实例，则分情况考虑：最坏情况、最好情况、平均情况；5）只考虑问题的规模充分⼤时函数的增长率，⽤渐近符号O 、Θ、Ω 、o 来表⽰。
6）常⽤O和Θ9.基本操作算法中的某个初等操作，基本操作的选择，必须反映出该操作随着输⼊规模的增加⽽变化的情况第⼆章递归算法1.递归若⼀个对象部分地包含它⾃⼰, 或⽤它⾃⼰给⾃⼰定义, 则称这个对象是递归的；若⼀个过程直接地或间接地调⽤⾃⼰, 则称这个过程是递归的过程。
分为直接递归和间接递归2.特点（1）将问题分解成为形式上更加简单的⼦问题来进⾏求解，递归过程⼀般通过函数或⼦过程来实现（2）问题求解规模缩⼩,把问题转化为规模缩⼩了的同类问题的⼦问题（3）相邻两次重复之间有紧密的联系（4）是否收敛，即终⽌条件3.使⽤递归的三种情况问题的定义数据结构问题求解的过程4.递归模型递归边界（递归的终⽌条件）和递归体5.过程先将整个问题划分为若⼲个⼦问题,通过分别求解⼦问题,最后获得整个问题的解。
算设计与分析复习要点总结
1. 算法定义：算法是解决问题的方法或过程。
算法的性质：输入：一个算法有零个或多个输入。
输出：一个算法有一个或多个输出。
确定性：算法中每一条指令必须有确切的含义，不存在二义性。
可行性：算法中的每条指令执行次数有限，执行时间时间也有限。
2.程序是算法用某种程序设计语言的具体实现，程序可以满足算法的有限性。
最基本的运算有：赋值运算，算数运算，逻辑运算，关系运算。
3. 数据分为，对象数据，结果数据，他们可以是所有类型中的任何一种类型。
表示方式有集合(枚举)，结构体，指针。
数据类型分为：boolean,byte,char,double,float,int,long,short.4. 描述算法的几种方式：自然语言方式，表格方式，图标（流程图），伪码语言(类程序设计语言)。
5. 算法的复杂性：是该算法所需要的计算机资源的多少，时间资源的量称为时间复杂性和空间资源的量称为空间复杂性。
用n，i，a表示算法要解的问题的规模，算法的输入，算法本身，而且c表示复杂性，应该有c=f（n，i，a）。
5.递归：直接或间接的调用本身的算法成为递归算法。
用函数自身给出定义的函数成为递归函数。
阶乘函数；n！={1 n=0；n（n-1）！n>0；}Public static int factorial(int n){If (n==0)return 1;Return n* factorial (n-1);}斐波那契（Fibonacci）数列F(n)= 1 n==0,1; F(n-1)+F(n-2) n>1;Public static int fib(int n){ if (n<=1) return 0;if (n>1) return fib(n-1)+fib(n-2);}排列问题：Public static void perm (obejt[]list,int k,int m){If (k==m){For (int i=0;i<=m;i++)System.out.print(list[i])System.out.println() }ElseFor (int i=k;i<=m;i++){mymath.swap(list ,k,i);Perm(list,k+1,m);Mymath.swap(list ,k,i); }}整数划分问题Public static int q(int n ,int m ){if ((n<1)||(m<1))return 0;If((n==1)||(m==1))return 1;If(n<m)return q(n,m-1)+1;Return q(n,m-1)+q(n-m,m);}6.系统需要在运行调用算法前先完成3件事情：1.为所有实参指针，返回地址等信息给被调用算法。
!算法设计与分析总复习
!算法设计与分析总复习算法设计与分析是计算机科学中非常重要的一个领域，它涉及到了算法的设计、性能分析和优化等方面。
在准备考试之前，我们需要对算法设计与分析的基本概念和常用算法进行全面复习。
一、算法设计与分析基本概念1.算法的定义：算法是一系列解决特定问题的有限步骤。
2.算法的特性：算法具有明确性、有限性、确定性和输入/输出。
3.算法的正确性：算法必须能够解决问题，并得到正确的答案。
4.算法的效率：算法的时间复杂度和空间复杂度是衡量算法效率的重要指标。
二、常用算法1.排序算法：常见的排序算法包括冒泡排序、插入排序、选择排序、快速排序、归并排序等。
需要了解每种排序算法的思想、时间复杂度和空间复杂度，并能够对其进行实现和优化。
2.查找算法：常用的查找算法包括顺序查找、二分查找、哈希查找等。
需要了解每种查找算法的思想和时间复杂度，并能够对其进行实现和应用。
3. 图算法：图算法包括深度优先（DFS）、广度优先（BFS）、最短路径算法（Dijkstra算法、Floyd算法）等。
需要了解这些算法的思想、时间复杂度和应用场景，并能够对其进行实现和应用。
4.动态规划算法：动态规划算法适用于具有重叠子问题和具有最优子结构性质的问题。
需要了解动态规划算法的基本思想、时间复杂度和应用场景，并能够对具体问题进行动态规划的设计和实现。
5.贪心算法：贪心算法常用于解决最优化问题，每一步都选择当前最优解，以期最终达到全局最优解。
需要了解贪心算法的基本思想、时间复杂度和应用场景，并能够对具体问题进行贪心算法的设计和实现。
三、算法的时间复杂度和空间复杂度1. 时间复杂度：算法的时间复杂度表示算法的执行时间和输入数据规模之间的关系。
常见的时间复杂度有O(1)、O(logn)、O(n)、O(nlogn)、O(n^2)等。
需要掌握各种时间复杂度的计算方法和复杂度的比较。
2.空间复杂度：算法的空间复杂度表示算法的内存消耗和输入数据规模之间的关系。
算法设计与分析期末总结
算法设计与分析期末总结一、课程概述算法设计与分析是计算机科学与技术专业核心课程之一，主要讲解算法的设计与分析方法。
通过学习该课程，我对算法设计和分析的基本概念、方法和工具有了深入的了解和掌握。
以下是我在该课程中的学习心得与总结。
二、学习内容1. 算法设计与分析的基本概念：学习了算法的定义、算法的设计、算法的复杂度等基本概念，了解了算法在计算中的重要性。
2. 分治法与递归法：学习了分治法与递归法的基本思想与原理，并运用分治法与递归法设计了一些典型的算法，如归并排序、快速排序等。
3. 动态规划：学习了动态规划的基本思想与原理，并通过实例学习了如何应用动态规划解决实际问题，如最长公共子序列问题、背包问题等。
4. 贪心算法：学习了贪心算法的基本思想与原理，并运用贪心算法解决了一些经典问题，如活动选择问题、霍夫曼编码问题等。
5. 图算法：学习了图的基本概念与遍历算法，了解了图的存储结构与遍历算法的实现，掌握了图的广度优先搜索与深度优先搜索算法。
6. NP完全问题与近似算法：学习了NP完全问题的定义与判定方法，了解了NP完全问题的困难性，学习了近似算法的设计与分析方法，并运用近似算法解决了一些实际问题。
三、学习方法1. 阅读教材与参考书籍：在课程学习过程中，我认真阅读了教材和相关参考书籍，对于课上讲解的概念和算法有了更深入的理解。
2. 完成编程作业：课程布置了一些编程作业，通过编写代码实现算法，我进一步理解了算法的具体实现细节。
3. 解题训练与思考：课程中也布置了一些习题和思考题，通过解题训练和思考，我进一步巩固了算法设计与分析的基本概念和方法。
四、学习收获1. 对算法设计与分析的基本概念与方法有了深入了解和掌握。
2. 对算法的复杂度分析方法和技巧有了更清晰的认识。
3. 加强了问题抽象和建模的能力，能够将实际问题转化为算法设计与分析的问题。
4. 提高了编程能力和算法实现的技巧，能够编写高效、优雅的代码。
5. 培养了思考和解决问题的能力，对于复杂的问题能够进行分析、拆解和解决。
算法设计与分析复习要点
算法设计与分析的复习要点第一章：算法问题求解基础算法是对特定问题求解步骤的一种描述，它是指令的有限序列。
一．算法的五个特征：1．输入：算法有零个或多个输入量；2．输出：算法至少产生一个输出量；3．确定性：算法的每一条指令都有确切的定义，没有二义性；4．可行性：算法的每一条指令必须足够基本，它们可以通过已经实现的基本运算执行有限次来实现；5．有穷性：算法必须总能在执行有限步之后终止。
二．什么是算法？程序与算法的区别1．笼统地说，算法是求解一类问题的任意一种特殊的方法；较严格地说，算法是对特定问题求解步骤的一种描述，它是指令的有限序列。
2．程序是算法用某种程序设计语言的具体实现；算法必须可终止，程序却没有这一限制；即：程序可以不满足算法的第5个性质“有穷性”。
三．一个问题求解过程包括：理解问题、设计方案、实现方案、回顾复查。
四．系统生命周期或软件生命周期分为：开发期：分析、设计、编码、测试；运行期：维护。
五．算法描述方法：自然语言、流程图、伪代码、程序设计语言等。
六．算法分析：是指对算法的执行时间和所需空间的估算。
算法的效率通过算法分析来确定。
七．递归定义：是一种直接或间接引用自身的定义方法。
一个合法的递归定义包括两部分：基础情况和递归部分；基础情况：以直接形式明确列举新事物的若干简单对象；递归部分：有简单或较简单对象定义新对象的条件和方法八．常见的程序正确性证明方法：1.归纳法：由基础情况和归纳步骤组成。
归纳法是证明递归算法正确性和进行算法分析的强有力工具；2.反证法。
第二章：算法分析基础一．会计算程序步的执行次数（如书中例题程序2-1,2-2,2-3的总程序步数的计算）。
二．会证明5个渐近记法。
（如书中P22-25例2-1至例2-9）三．会计算递推式的显式。
（迭代法、代换法，主方法）四．会用主定理求T(n)=aT(n/b)+f(n)。
（主定理见P29，如例2-15至例2-18）五．一个好的算法应具备的4个重要特征：1.正确性：算法的执行结果应当满足预先规定的功能和性能要求；2.简明性：算法应思路清晰、层次分明、容易理解、利于编码和调试；3.效率：算法应有效使用存储空间，并具有高的时间效率；4.最优性：算法的执行时间已达到求解该类问题所需时间的下界。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
大学算法分析与设计复习总结为了拿大学的那悲剧的学分，好好弄懂以下所有知识点吧。
把老师的复习的提纲，特意汇总了所有考点，方便童鞋们复习。
不喜勿喷！！！这本书是《算法设计与分析》王红梅编著一共有以下12章，我们学了1、3、4、5、6、7、8、9分别是“绪论、蛮力法、分治法、减治法、动态规划法、贪心法、回溯法、分治限界法第1章绪论考点：1、算法的5个重要特性。
（P3）答：输入、输出、有穷性、确定性、可行性2、描述算法的四种方法分别是什么，有什么优缺点。
（P4）答：1. 自然语言优点：容易理解；缺点：容易出现二义性，并且算法都很冗长。
2. 流程图优点：直观易懂；缺点：严密性不如程序语言，灵活性不如自然语言。
3. 程序设计语言优点：用程序语言描述的算法能由计算机直接执行；缺点：抽象性差，是算法设计者拘泥于描述算法的具体细节，忽略了“好”算法和正确逻辑的重要性，此外，还要求算法设计者掌握程序设计语言及其编程技巧。
伪代码优点：表达能力强，抽象性强，容易理解3、了解非递归算法的时间复杂性分析。
(P13)要点：对非递归算法时间复杂性的分析，关键是建立一个代表算法运行时间的求和表达式，然后用渐进符号表示这个求和表达式。
非递归算法分析的一般步骤是：（1）决定用哪个（或哪些）参数作为算法问题规模的度量。
（2）找出算法的基本语句。
（3）检查基本语句的执行次数是否只依赖问题规模。
（4）建立基本语句执行次数的求和表达式。
（5）用渐进符号表示这个求和表达式。
[例1.4]：求数组最小值算法int ArrayMin(int a[ ], int n){min=a[0];for (i=1; i<n; i++)if (a[i]<min) min=a[i];return min;}问题规模：n基本语句：a[i]<minT(n)= n-1=O(n)4、掌握扩展递归技术和通用分治递推式的使用。
（P15）扩展递归技术：通用分支递归式：5、习题1-4，习题1-7设计算法求数组中相差最小的两个元素（称为最接近数）的差。
要求给出伪代码描述，并用一组例子进行跟踪验证，写出验证过程。
（1）伪代码1. 令最小距离min等于数组头两个元素R[0]和R[1]的差的绝对值；2. 从i=0循环至i<n-1，对于每个R[i]2.1 分别求其与j=i+1至j<n的数的差的绝对值；2.2 如果此值小于最小距离，则令新的最小距离为此值；3. 输出最小距离。
（2）用实例进行跟踪验证R[6]={10,5,11,16,30,14},n=6;Min=|10-5|=5;i=0,j=1, |R[i]-R[j]|=|10-5|=5;j=2,|R[i]-R[j]|=|10-11|=1<min;min=1;j=3, |R[i]-R[j]|=|10-16|=6;j=4, |R[i]-R[j]|=|10-30|=20;j=5, |R[i]-R[j]|=|10-14|=4;i=1,j=2, |R[i]-R[j]|=|5-11|=6;j=3, |R[i]-R[j]|=|5-16|=11;j=4, |R[i]-R[j]|=|5-30|=15;j=5, |R[i]-R[j]|=|5-14|=9;i=2,j=3, |R[i]-R[j]|=|11-16|=5;j=4, |R[i]-R[j]|=|11-30|=19;j=5, |R[i]-R[j]|=|11-14|=3;i=3,j=4, |R[i]-R[j]|=|16-30|=14;j=5, |R[i]-R[j]|=|16-14|=2;i=4,j=5, |R[i]-R[j]|=|30-14|=16;最后输出min=17、使用扩展递归技术求解下列递推关系式（1）（2）第3章蛮力法1、掌握蛮力法的设计思想：蛮力法依赖的基本技术——扫描技术，即采用一定的策略将待求解问题的所有元素依次处理一次，从而找出问题的解;关键——依次处理所有元素。
2、蛮力法的代表算法及其时间复杂度：顺序查找，O(n)串匹配（BF O(n*m)，KMP O(n+m)，BM O(n*m)）选择排序，O(n2)冒泡排序，O(n2)生成排列对象（排列问题），O(n!)生成子集（组合问题），O(2n)0/1背包属于组合问题。
任务分配，哈密顿回路，TSP问题属于排列问题。
最近对问题O(n2)，凸包问题O(n3)3、掌握BF和KMP算法的原理，能够画出比较过程。
P71习题3的4。
要求给出一串字符串，能够求出对应的next数组，并能使用KMP算法进行比较匹配。
4、掌握选择排序和冒泡排序算法描述和时间复杂性，要求能够写出伪代码。
（P56-58）选择排序算法描述：选择排序开始的时候，扫描整个序列，找到整个序列的最小记录和序列中的第一记录交换，从而将最小记录放到它在有序区的最终位置上，然后再从第二个记录开始扫描序列，找到n-1个序列中的最小记录，再和第二个记录交换位置。
一般地，第i趟排序从第i 个记录开始扫描序列，在n-i+1个记录中找到关键码最小的记录，并和第i个记录交换作为有序序列的第i个记录。
时间复杂性：O(n2)伪代码：冒泡排序算法描述：冒泡排序开始的时候扫描整个序列，在扫描过程中两两比较相邻记录，如果反序则交换，最终，最大记录就能被“沉到”了序列的最后一个位置，第二趟扫描将第二大记录“沉到”了倒数第二个位置，重复上述操作，直到n-1趟扫描后，整个序列就排好序了。
冒泡排序，O(n2)5、算法设计题：习题3-3，3-6，3-8，3-11，3-133-3 对于KMP算法中求next数组问题，设计一个蛮力算法，并分析其时间性能。
[cpp]view plaincopyprint?1.voidGetNext(char T[ ], int next[ ])2.{3. next[1]=0;4. next[2]=1;5. j=T[0],k=0;6.for(;j>2;j--){7.for(n=j-2;n>=1;n--){//n为要比较的前缀的最后一个字符的下标8. m=j-n;//m为要比较的后缀的第一个字符的下标9.for(i=1;i<=n;i++)10. {11.if(T[i]!=T[m+i-1])break;12. }13.if(i==n+1){next[j]=n+1;break;}14. }15.if(n==0)next[j]=1;16. }17.}3-4 假设在文本“ababcabccabccacbab”中查找模式“abccac”,求分别采用BF算法和KMP算法进行串匹配过程中的字符比较次数。
由此可知，用BF算法一共要进行3+1+4+1+1+6+1+1+1+6=25次比较方能匹配出KMP算法：next[]={,0,1,1,1,1,2};由此可知，用KMP算法一共要进行3+4+6+5=18次比较方能匹配出参考代码如下：排列最终存储在长度为n的阶乘，元素类型为指针的数组中，数组指向一个排列，具体的排列数据存储在数组中。
[cpp]view plaincopyprint?1.int fabs(int n)2.{3.int r=1;4.for(inti=n;i>1;i--)5. r=r*i;6.return r;7.8.}9.10.//排列存储在数组中11.void getArrangement(int**&s,int n)12.{13.int * p,*q;14.int * *s1;15.int i,j,k,l,m,o;16. s=new int *[1];17. s[0]=newint[1];18. s[0][0]=1;19.for(i=2;i<=n;i++)20. {21. j=0;22. o=0;23. m=fabs(i-1);24. s1=newint *[fabs(i)];25.while(o<m)26. {27. q=p=s[o];28.for(k=i-1;k>=0;k--)29. {30. s1[j]=newint[i];31.for(l=0;l<i;l++)32. {33.if(l==k){s1[j][l]=i;}34.else{35. s1[j][l]=*p;36. p++;}37. }38. j++;39. p=q;40. }41. o++;42.delete[] q;43. }44.delete[]s;45. s=s1;46. }47.}3-8对于一个平面上n个点的集合S，设计蛮力算法求集合S的凸包的一个极点。
点集合中最左边或者最右边的点一定是凸包的一个极点，则求凸包的极点的问题转化为求点的x坐标最大或最小的点[cpp]view plaincopyprint?1.int getPole(int x[],int y[],int n)2.{3.int r=0;4.for(inti=0;i<n;i++)5. {6.if(x[i]>x[r])r=i;7. }8.return r;9.}<span style="font-weight: bold; "> </span>3-11 设计算法生成在n个元素中包含k个元素的所有组合对象。
两种思路：1、生成所有的组合，在组合中找元素个数为k个的组合。
伪代码：1．初始化一个长度为n的比特串s=00…0并将对应的子集输出；2．for(i=1; i<2n; i++) //注意不能书写成i<=2n2.1 s++；2.2 判断s中1的个数，若为k，则将s对应的子集输出；2、使用k层嵌套循环生成元素个数为k个的组合。
设k=3；n个元素存储在数组a[]中；伪代码：for (i=1; i<n-2; i++)for(j=i+1; i<n-1; i++)for(k=j+1; i<n; i++)输出a[i]a[j]a[k]构成的组合。
3-13美国有个连锁店叫7-11这个连锁店以前是每天7点开门，晚上11点关门不过现在是全天24小时营业。
有一天，有个人来到这个连锁店，买了4件商品营业员拿起计算器敲了一下，说：总共是$7.11顾客开玩笑说：所以你们商店就叫7-11？营业员没有理她，说：当然不是，我是把它们的价格相乘之后得到的。
顾客说：相乘？你应该把他相加才对。
营业员说，我弄错了。
接着又算了一遍，结果让两个人吃惊的是：计算结果也是$7.11请问，这4件商品的价格是多少？参考代码：[cpp]view plaincopyprint?1.#include<iostream.h>2.#include <stdio.h>3.int main()4.{5.long i,j,k,m;6.7.for (i=1; i <=711/4 ; i++)8.{9.for (j=i; j <=711/3 ; j++)10.{11.for (k=j; k <=711/2 ; k++)12.{13.m=711-i-j-k;14.if (i*j*k*m==711*1000000)15.{16.cout<<i<<endl<<j<<endl<<k<<endl<<m<<endl;17. }18.}19.}20.}21.return 0;22.}输出结果为：价格分别是1.2 1.25 1.5 3.16第4章分治法了解分治法的设计思想设计思想：将要求解的原问题划分成k个较小规模的子问题，对这k个子问题分别求解。