第四次算法作业-荆楠
算法作业-13S103049荆楠
13S103049 荆楠高宏班作业：1证明f(n)=an 2+bn+c=θ(n 2)证明：令c 1 = 14a, c 2 = 74a, n 0 = 2·max(|b |a,√|c |a)当n ＞n 0时，an 2+bn+c- c 1n 2 =34an 2+bn+c = 12an(n+2b a)+ 14a(n 2+4ca)＞0即an 2+bn+c≥ c 1n 2c 2n 2-(an 2+bn+c) =34an 2-bn-c = 12an(n- 2ba)+ 14a(n 2 -4c a)＞0即an 2+bn+c≤ c 2n 2因此，当n ＞n 0后，恒有0＜c 1n 2≤an 2+bn+c≤ c 2n 2 故f(n)=an 2+bn+c=θ(n 2)成立。
2证明6n 3≠θ(n 2)证明：假设6n 3=θ(n 2)成立，根据定义，存在常数c 1、c 2＞0，n 0＞0使得n ＞n 0时恒有0＜c 1n 2≤6n 3≤ c 2n 2不等式右边化简得n≤c26，由于c 2为常数，与n 可以无穷大相矛盾，故假设不成立，因此6n 3≠θ(n 2)。
3证明P(n) = ∑a in i d i=0=θ(n d ) 证明：由于∑a i n i d i=0≤(d+1)max{a i }n d =Ο(n d )∑a i n i d i=0≥a d n d =Ω(n d)因此，由定理1可知，P(n) = ∑a in id i=0=θ(n d )。
4证明n=Ο(n 2)证明：令c=1，n 0=1，当n 大于n 0时，有0≤n≤c n 2=n 2成立，因此，n=Ο(n 2)成立。
5如果f(n)= θ(g(n))，则f(n)= Ο(g(n))证明：由f(n)= θ(g(n))定义知，∃c 1，c 2＞0，n 0＞0，使得n ＞n 0后恒有0≤c 1f(n)≤g(n) ≤c 2f(n)，因此，当n ＞n 0时，恒有0≤g(n) ≤c 2f(n)， 故f(n)= Ο(g(n))。
算法竞赛入门经典训练指南题单
算法竞赛入门经典训练指南题单全文共四篇示例，供读者参考第一篇示例：算法竞赛作为计算机科学领域中的重要领域之一，一直备受关注和推崇。
参加算法竞赛可以帮助我们提高编程能力、思维灵活性和解决问题的能力。
而且，通过算法竞赛，我们还可以结识来自各个国家的优秀程序员，开阔自己的视野，提高自己的竞争力。
而要在算法竞赛中取得好成绩，就需要有一定的训练和积累。
本文将为大家推荐一些经典的算法竞赛训练题单，希望能帮助大家快速入门和提升自己的算法竞赛水平。
1. ACM-ICPC题单ACM国际大学生程序设计竞赛（ACM-ICPC）是全球规模最大、最具影响的大学生程序设计竞赛，被誉为程序设计界的“奥林匹克”。
ACM-ICPC赛题难度较高，对参赛者的编程能力、算法设计能力和团队协作能力等方面都有严格的要求。
参加ACM-ICPC的同学们需要有一定的训练和备战。
以下是一些经典的ACM-ICPC训练题单，推荐给大家：1、CodeforcesCodeforces是一个国际知名的在线编程比赛和训练平台，其比赛难度较高，同时也有很大的影响力。
在Codeforces上，你可以找到各种难度的题目，从入门级到专家级都有覆盖。
推荐大家在Codeforces 上刷题，提高自己的编程能力和解题能力。
3、洛谷洛谷是国内著名的在线题库和训练平台，里面汇集了大量的ACM 竞赛题目和OJ题目，适合广大程序员练习和提升编程能力。
洛谷上的题目分类清晰，难度适中，非常适合新手入门和提高。
2. Google Code Jam题单Google Code Jam是由谷歌主办的一项全球性的编程大赛，是程序员们展示自己编程才华的绝佳舞台。
Google Code Jam的题目设计独特，难度适中，涵盖了很多经典的算法问题，非常适合有一定编程基础的程序员练习和挑战。
以下是一些推荐的Google Code Jam题单：LeetCode是一个在线的编程练习平台，里面包含了大量的算法和数据结构问题，适合练习和提升自己的编程能力。
算法设计与分析常见习题及详解
算法设计与分析常见习题及详解⽆论在以后找⼯作还是⾯试中，都离不开算法设计与分析。
本博⽂总结了相关算法设计的题⽬，旨在帮助加深对贪⼼算法、动态规划、回溯等算法的理解。
1、计算下述算法执⾏的加法次数：输⼊：n =2^t //t 为整数输出：加法次数 k K =0while n >=1 do for j =1 to n do k := k +1 n = n /2return k解析：第⼀次循环执⾏n次加法，第⼆次循环执⾏1/2次加法，第三次循环执⾏1/次加法…因此，上述算法执⾏加法的次数为==2n-12、考虑下⾯每对函数 f(n) 和 g(n) ，如果它们的阶相等则使⽤Θ记号，否则使⽤ O 记号表⽰它们的关系解析：前导知识：，因为解析：，因为解析:，因为解析：解析:3、在表1.1中填⼊ true 或 false解析：利⽤上题的前导知识就可以得出。
2=21/4n +n +21n +41...+1n +n −n +21n −21n +41....−1f (n )=(n −2n )/2，g (n )=6n1<logn <n <nlogn <n <2n <32<n n !<n ng (n )=O (f (n ))f (n )=Θ(n ),g (n )=2Θ(n )f (n )=n +2,g (n )=n n 2f (n )=O (g (n ))f (n )=Θ(n ),g (n )=Θ(n )2f (n )=n +nlogn ,g (n )=n nf (n )=O (g (n ))f (n )=Θ(nlogn ),g (n )=Θ(n )23f (n )=2(log ),g (n )=n 2logn +1g (n )=O (f (n ))f (n )=log (n !),g (n )=n 1.05f (n )=O (g (n ))4、对于下⾯每个函数 f(n),⽤f(n) =Θ(g(n))的形式，其中g(n)要尽可能简洁，然后按阶递增序排列它们（最后⼀列）解析：最后⼀个⽤到了调和公式：按阶递增的顺序排列：、、、、、、、、、(n −2)!=Θ((n −2)!)5log (n +100)=10Θ(logn )2=2n Θ(4)n 0.001n +43n +31=Θ(n )4(lnn )=2Θ(ln n )2+3n logn =Θ()3n 3=n Θ(3)n log (n !)=Θ(nlogn )log (n )=n +1Θ(nlogn )1++21....+=n1Θ(logn )=∑k =1nk 1logn +O (1)1++21....+n 15log (n +100)10(lnn )2+3n logn log (n !)log (n )n +10.001n +43n +313n 22n (n −2)!5、求解递推⽅程前导知识：主定理前导知识：递归树：例⼦：递归树是⼀棵节点带权的⼆叉树，初始递归树只有⼀个结点，标记为权重W(n)，然后不断进⾏迭代，最后直到树种不再含有权为函数的结点为⽌，然后将树根结点到树叶节点的全部权值加起来，即为算法的复杂度。
算法 第四版 习题 答案
1.1.1 给出以下表达式的值：a. ( 0 + 15 ) / 2b. 2.0e-6 * 100000000.1c. true && false || true && true答案：a.7,b.200.0000002 c.ture1.1.2 给出以下表达式的类型和值：a. (1 + 2.236)/2b. 1 + 2 + 3 + 4.0c. 4.1 >= 4d. 1 + 2 + "3"答案：a.1.618 b. 10.0 c.true d.331.1.3 编写一个程序，从命令行得到三个整数参数。
如果它们都相等则打印equal，否则打印not equal。
public class TestUqual{public static void main(String[] args){int a,b,c;a=b=c=0;StdOut.println("Please enter three numbers");a =StdIn.readInt();b=StdIn.readInt();c=StdIn.readInt();if(equals(a,b,c)==1){StdOut.print("equal");}else{StdOut.print("not equal");}}public static int equals(int a ,int b , int c){if(a==b&&b==c){return 1;}else{return 0;}}}1.1.4 下列语句各有什么问题（如果有的话）？a. if (a > b) then c = 0;b. if a > b { c = 0; }c. if (a > b) c = 0;d. if (a > b) c = 0 else b = 0;答案：a. if (a > b) c = 0; b. if (a > b) { c = 0; }1.1.5 编写一段程序，如果double 类型的变量x 和y 都严格位于0 和1 之间则打印true，否则打印false。
算法_第四版_习题_答案
算法第四版习题答案1.2/** 1.2.1 编写一个Point2D的用例，从命令行接受一个整数N。
在单位正方形内生成N个随机点，然后计算两点之间的最近距离*/public class testPoint2D {public testPoint2D() {// TODO Auto-generated constructor stub}public static void drawbox(double bw, double bh){StdDraw.setPenRadius(0.005);StdDraw.setPenColor(StdDraw.RED);Interval1D xinterval = new Interval1D(0, bw);Interval1D yinterval = new Interval1D(0, bh);Interval2D box = new Interval2D(xinterval, yinterval);box.draw();}public static Point2D[] drawpoint(int N){Point2D[] p=new Point2D[N];for(int i=0;i<N;i++){double x=Math.random();double y=Math.random();p[i]=new Point2D(x, y) ;p[i].draw();}return p;}public static double findmindist(Point2D[] p){Point2D p1=p[0];Point2D p2=p[1];double mindist =p[0].distanceTo(p[1]);StdDraw.setPenRadius(0.002);StdDraw.setPenColor(StdDraw.RED);int n=p.length ;for(int i=1;i<n-1;i++)for(int j=i+1;j<n;j++){double temp=p[i].distanceTo(p[j]);if(temp<mindist){ mindist=temp;p1=p[i];p2=p[j];}}p1.drawTo(p2);StdOut.print("min dist="+mindist +p1.toString()+p2.toString());return mindist;}public static void main(String[] args) {int N=StdIn.readInt();//读取画点的数量//StdDraw.setXscale(0,1 );//StdDraw.setYscale(0,1);drawbox(1,1);//画出一个单位大小的正方形StdDraw.setPenRadius(0.01);StdDraw.setPenColor(StdDraw.BLACK);//drawpoint(N);//画出N个点double min=findmindist(drawpoint(N));}}/** 编写一个Interval1D的用例，从命令行接受一个整数N。
算法分析与设计作业及参考答案
算法分析与设计作业及参考答案作业题目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)。
算法第三章作业-13S103049荆楠
42; 5; 15; 27; 29> 29; 35; 42; 5; 15>。 (1)假设 k 已知， 给出一个时间复杂度为 O(1)的算法找出 A 中的最大 元素。 (2)假设 k 未知， 设计一个时间复杂度为 O(logn)的算法找出 A 中的最 大元素。 答：设组 A 中共有 n 个元素，记为 A[1:n]。观察该数组知除了最大元 素外，右侧相邻元素均大于左侧元素。 (1)算法思想：若要找出最大元素，只需要令 m=k%n，若 m=0,则最大 元素为 A[n];若 m≠0，则 A[m]即为所求，时间复杂度为 O(1)。 Input:A[1:n]； Output:max(A[i]),1≤i≤n； FindMax(A,k, n) 1 m=k%n; 2 if m=0 3 4 then return A[n]； else return A[m];
Main(A,1,n) 1 count←0 2 ISMerge-Sort(A,1,n,count) 3 return count (3)由于此算法是在 Merge-Sort 算法中，Merge 阶段增加了计数过程， 该步骤复杂度为 O(1)， 因此， 总得算法时间复杂度与合并排序算法相 同，为 O(nlogn)。 3、给定一个由 n 个实数构成的集合 S 和另一个实数 x，判断 S 中是 否有两个元素的和为 x。试设计一个分治算法求解上述问题，并分析 算法的时间复杂度。 答：算法思想：首先对集合 S 内的 n 个实数进行合并排序，接着对排 序后 S 内的每一个元素 S[i]，求得 z=x-S[i], 利用二分查找法在 S 中 寻找 z, 若找到则输出结果，否则不存在。 伪代码描述： Input：一个由 n 个实数构成的集合 S,记为 S[1:n]
1、设 X[0:n-1]和 Y[0:n-1]为两个数组，每个数组中的 n 个均已经排 好序，试设计一个 O(log(n))的算法，找出 X 和 Y 中 2n 个数的中位 数，并进行复杂性分析。 答： 算法思想： 首先找出 X 的中位数 a=X[⌈ ⌉]与 Y 的中位数 b=Y[⌊ ⌋]，
《深入算法三》
《深入算法三》作文，希望您能喜欢！---嘿，朋友们！今天我要跟你们讲讲我遇到的一件和算法有关的趣事。
前阵子，我参加了一个数学竞赛的培训。
在那个培训班里，我认识了一群和我一样对数学充满热情的小伙伴。
有一天，老师在黑板上出了一道超级复杂的数学题，说是要考验我们对算法的理解和运用。
题目大概是这样的：有一堆水果，苹果、香蕉和橙子，它们的数量各不相同，然后要通过一系列的计算和推理，得出它们各自的数量。
我看着那道题，脑袋都快大了。
这时候，旁边的小李凑过来跟我说：“嘿，这题看起来好难啊，咱们一起想想呗。
”我点点头，心里想着多个人多个思路。
我们俩就开始在草稿纸上写写画画，尝试各种算法。
小李说：“要不咱们先假设苹果有 X 个，香蕉有 Y 个，橙子有 Z 个？”我回道：“行啊，那咱试试看。
”就在我们俩苦思冥想的时候，后面的小王也忍不住加入了进来。
他看了看我们的草稿，笑着说：“你们这思路有点乱啊，我觉得可以先从已知条件里找关键信息。
”于是，我们三个人你一言我一语，讨论得热火朝天。
一会儿小李说这个算法不行，一会儿小王又提出新的想法。
经过一番折腾，我们终于找到了一种可行的算法。
当算出答案的那一刻，我们仨兴奋得差点跳起来。
通过这件事，我深深感受到，算法这东西，就像是一个神秘的宝藏，得靠我们不断地探索和尝试，还得和小伙伴们一起合作，才能找到打开它的钥匙。
现在回想起来，那次的经历真是太有趣啦，也让我对算法有了更深的认识和兴趣。
---以上作文仅供参考，您可以提出更多的要求和建议，比如修改具体的情节、加入更多的人物特点等，我会为您生成更符合您需求的内容。
算法考卷参考答案
一、选择题（每题1分，共5分）A. Dijkstra算法B. Kruskal算法C. Huffman编码D. 动态规划算法2. 下列排序算法中，哪个算法的时间复杂度最稳定？A. 冒泡排序B. 快速排序C. 堆排序D. 插入排序A. 二分查找B. 深度优先搜索C. 广度优先搜索D. 动态规划A. 初始化状态B. 确定状态转移方程C. 计算最优值D. ABC都是A. Floyd算法B. Warshall算法C. Prim算法D. BellmanFord算法二、判断题（每题1分，共5分）1. 算法的空间复杂度与时间复杂度成正比。
（×）2. 贪心算法总能得到最优解。
（×）3. 快速排序的平均时间复杂度为O(nlogn)。
（√）4. 二分查找算法适用于顺序存储的有序表。
（√）5. 深度优先搜索和广度优先搜索在遍历图时，时间复杂度相同。
（×）三、填空题（每题1分，共5分）1. 算法的五个基本特性分别是：可行性、确定性、______、有穷性和输入输出。
2. 在排序算法中，堆排序的时间复杂度为______。
3. 求解背包问题通常采用______算法。
4. 图的遍历方法有深度优先搜索和______。
5. 在动态规划算法中，状态转移方程描述了______之间的关系。
四、简答题（每题2分，共10分）1. 简述冒泡排序的基本思想。
2. 什么是贪心算法？请举例说明。
3. 简述二分查找算法的基本步骤。
4. 什么是动态规划算法？它适用于哪些问题？5. 请列举三种常见的图遍历算法。
五、应用题（每题2分，共10分）1. 设有数组arr = [3, 5, 1, 4, 2]，请用冒泡排序算法对数组进行排序。
2. 给定一个整数数组nums，请找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
3. 编写一个递归函数，实现求斐波那契数列的第n项。
A B| |C DA B (3)| |C D (4)六、分析题（每题5分，共10分）def func(n):sum = 0for i in range(n):for j in range(i):sum += 1return sum2. 给定一个字符串str，请设计一个算法，找出最长不重复子串的长度。
软件设计师下午题第四题技巧
软件设计师下午题第四题技巧
1. 哎呀呀，对于软件设计师下午题第四题，你得先认真审题呀！就好比走路得看清路一样，马虎不得。
比如说，题目让你设计个算法，你不看清需求能行吗？
2. 然后呢，一定要理清思路！这就好比整理房间，得有个先后顺序呀。
举个例子，遇到复杂的数据结构题目，先从最基础的部分开始想呀。
3. 还有哦，多画一画流程图呀！就像给你的思路画个地图，清楚明白。
比如在解决流程相关问题时，画个图不就一目了然了嘛。
4. 别忘了利用以往的经验呀！以前做过类似的题，那就是你的宝库呀。
就好像你有了一把万能钥匙，遇到相似问题就能轻松打开了。
5. 注意细节呀，可别小瞧它们！细节就像是大楼的基石，一点差错都可能导致功亏一篑。
比如一个小的边界条件没考虑到，可能整道题都错了哟。
6. 多和小伙伴讨论讨论呀！众人拾柴火焰高嘛。
比如说，你对一个解法有疑问，一讨论不就清楚多了。
7. 保持冷静呀，别一遇到难题就慌了神。
这就好比打仗，沉着冷静才能打胜仗啊。
假如题目很难，你急有啥用呢？
8. 要不断练习呀！熟能生巧这词儿可真不假。
你看那些高手，不都是练出来的嘛。
多做几道题，到时候自然就得心应手了。
我觉得呀，只要掌握了这些技巧，软件设计师下午题第四题就不再那么可怕啦！。
算法试题及答案
算法试题及答案一、选择题1. 以下哪个选项不是排序算法？A. 快速排序B. 归并排序C. 冒泡排序D. 深度优先搜索答案：D2. 在二叉树的遍历算法中，中序遍历的顺序是什么？A. 根-左-右B. 左-根-右C. 右-根-左D. 根-右-左答案：B二、填空题1. 在图论中，一个图中的顶点数为n，边数为m，那么这个图的邻接矩阵的维度是________。
答案：n×n2. 动态规划算法的核心是________。
答案：最优子结构三、简答题1. 请简述贪心算法和动态规划算法的区别。
答案：贪心算法在每一步选择局部最优解，而不考虑全局最优解；动态规划算法则是将问题分解成子问题，通过求解子问题的最优解来构建原问题的最优解。
2. 什么是分治算法？请举例说明。
答案：分治算法是一种递归算法，它将问题分解成更小的子问题，递归求解子问题，然后将子问题的解合并以得到原问题的解。
例如，快速排序就是一种分治算法，它通过选择一个基准值，将数组分成两部分，一部分比基准值小，另一部分比基准值大，然后递归地对这两部分进行快速排序。
四、编程题1. 编写一个函数，实现字符串的反转。
答案：```pythondef reverse_string(s):return s[::-1]```2. 给定一个整数数组，请编写一个函数，找出数组中第二大的数。
答案：```pythondef find_second_max(nums):first_max = second_max = float('-inf')for num in nums:if num > first_max:second_max = first_maxfirst_max = numelif num > second_max and num != first_max:second_max = numreturn second_max```。
《创新算法四》
《创新算法四》
嘿，朋友们！今天我要和你们讲讲我所经历的一件超级有趣的事儿，它让我对创新有了新的认识。
那是在我们小镇举办的一次手工创意比赛上。
我和几个小伙伴兴致勃勃地报了名，想着一定要搞出点新奇的玩意儿来。
比赛一开始，大家都忙得热火朝天。
我旁边的小李，瞪着一双大眼睛，嘴里念念有词：“哎呀，我得做个最酷的木雕，让大家都佩服我！”我瞅了瞅他，笑了笑说：“行啊，那你可得加油啦！”我呢，心里想着做一个独特的纸艺作品。
我正埋头苦干的时候，对面的小王凑过来，好奇地问：“你这是要做啥呀？”我神秘地眨眨眼：“先不告诉你，等完成了你就知道啦！”
我不停地摆弄着那些彩纸，一会儿剪，一会儿折，一会儿又用胶水粘。
这过程可不简单，好几次我都差点搞砸了。
就在我焦头烂额的时候，突然灵光一闪，想到了一个新的办法。
我把原本打算竖着粘的纸条横着粘，嘿，效果居然出奇的好！
最后，比赛结束，我的作品虽然没有像我最初想象的那样完美，但却有着独特的魅力。
评委们都对我的创新思路称赞有加。
通过这次经历，我明白了，创新有时候就像是一场冒险，你得大胆尝试，不怕犯错，说不定就能找到那个神奇的“算法”，创造出与众不同的东西来。
这就是我关于创新的一次有趣体验，你们觉得怎么样？。
算法导论第四章思考题
算法导论第四章思考题1. 算法的魅力说到算法，很多人可能会觉得那是高深莫测的东西，像天上的星星，让人看得眼花缭乱。
不过，别急，我们今天就来聊聊这个看似复杂其实也挺有意思的东西。
算法就像是解决问题的一个万能钥匙，不管是数学难题、数据处理，还是生活中的小困扰，它都能给你指引方向。
就像你在厨房里想做一道新菜，但找不到食谱，结果你随便乱加一通，最后倒成了一锅粥。
其实，好的算法就像是完美的食谱，教你一步一步做出美味的佳肴，避免一切的“锅里翻船”。
1.1 算法的分类首先，我们得搞清楚，算法可不是一成不变的，它们有各自的类型。
比如，有的算法是用来排序的，有的则是用来搜索的。
你可以想象一下，排序算法就像是在舞台上，给一群舞者排队，看看谁该在前，谁该在后。
而搜索算法就像是侦探，四处寻找线索，试图找到隐藏在数据中的宝藏。
这些算法不仅让我们的生活变得简单，还能让我们的工作效率倍增，真是一举两得，何乐而不为呢？1.2 算法的应用接下来，我们得聊聊算法的应用。
无论是在网上购物、社交媒体，还是在你每天使用的各种手机应用，算法都在默默地工作。
比如，当你在某个电商网站上购物时，推荐算法会根据你的浏览记录，推荐那些你可能会喜欢的商品，简直像是个贴心的购物小助手，时刻关注你的需求。
当然，有时候它也会搞笑地推荐一些你绝对不会买的东西，让你忍不住笑出声来。
2. 算法的复杂度当然，聊完了算法的应用，我们得面对一个严肃的话题——算法的复杂度。
别担心，不是让你背公式，咱们简单说说就好。
算法的复杂度就像是一个人走路的速度，速度快了，自然效率高。
我们通常用“时间复杂度”和“空间复杂度”来衡量算法的效率。
想象一下，你在街上逛，一个人走得飞快，另一个人慢悠悠，结果你会选择跟哪个人一起走呢？没错，当然是那个快的！这就是时间复杂度的重要性，效率是王道。
2.1 时间复杂度时间复杂度主要是关注算法执行所需的时间。
我们常常看到一些算法的复杂度被表示为O(n)、O(log n)等。
大学生创新素质实战训练第四次作业
第四次作业管科三班李世东201100270467第一天：A组奥巴马新闻专业水污染饮料B组德鲁克管理台灯机械教室奥巴马德鲁克：他们都是美国人。
新闻台灯：可以在台灯下看新闻。
饮料管理：制造饮料要有人管理。
专业机械：做很多专业需要机械。
水污染机械：治理水污染要用到机械。
饮料教室：可以在教室喝饮料。
第二天：A组衰老毒品美容化学实验百度B组花儿黑色乞丐状元女人衰老花：花会衰老。
花毒品：罂粟花是毒品。
化学实验女人：居里夫人做化学实验。
美容女人：女人爱做美容。
乞丐百度：百度可以找到关于乞丐的文档。
化学实验状元;高考状元化学实验会做的很好。
第三天：A组烤面包先知数字计算游戏尾部政客B组跑道公式棒棒糖领袖金字塔烤面包跑道：都是椭圆形的。
先知金字塔：都很神秘。
数学计算公式公式：都和数学有关系。
先知棒棒糖：先知可能喜欢吃棒棒糖。
政客领袖：政客可能做领袖。
第四天网杯子火腿铝凉鞋从网的用途想到他可以做杯子的茶网，从杯子的用途是喝水喝酒，然后想到吃饭，吃饭然后吃火腿，火腿的用途可以做菜，做菜可能用铝制的厨具，铝可以用来制作凉鞋的鞋扣第五天电视建筑月光侠客长江七号电视的用途是看节目，可以看到关于建筑的；建筑的作用是供人居住，人们晚上可以在里面看月光；月光是秦时明月的主题曲，秦时明月是关于侠客的；侠客总是助人为乐，长江七号的七仔也是。
第六天方便面疯牛病英国海轮船方便有红烧牛肉面，所以想到牛，然后想到疯牛病；疯牛病的概念是英国提出的；英国曾是日不落帝国，所以是海上霸主，想到海；还可以用来托起轮船。
算法大赛试题及答案
算法大赛试题及答案1. 问题描述给定一个整数数组，请找出数组中第二大的数。
2. 输入格式第一行包含一个整数N，表示数组的长度。
第二行包含N个整数，表示数组的元素。
3. 输出格式输出第二大的整数。
4. 样例输入53 14 1 55. 样例输出46. 问题分析要解决这个问题，我们可以使用一次遍历的方法。
首先初始化两个变量，一个用来保存数组中的最大值，另一个用来保存第二大的值。
遍历数组，对于每个元素，如果它大于当前的最大值，则更新第二大的值和最大值；如果它小于当前的最大值但大于第二大的值，则更新第二大的值。
7. 算法实现```pythondef find_second_max(nums):first_max = second_max = float('-inf')for num in nums:if num > first_max:second_max = first_maxfirst_max = numelif num > second_max and num != first_max: second_max = numreturn second_max# 读取输入N = int(input().strip())nums = list(map(int, input().strip().split()))# 输出第二大的数print(find_second_max(nums))```8. 测试用例- 输入: `4` `1 2 3 4`输出: `3`- 输入: `6` `10 20 10 30 20 40`输出: `30`9. 注意事项- 如果数组中所有元素都相同，则不存在第二大的数。
- 如果数组中只有一个元素，则不存在第二大的数。
10. 复杂度分析- 时间复杂度：O(N)，其中N是数组的长度。
- 空间复杂度：O(1)，只需要常数级别的额外空间。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
1.现有一台计算机，在某个时刻同时到达了n个任务。
该计算机在同一时间只能处理一个任务，每个任务都必须被不间断地得到处理。
该计算机处理这n个任务需要的时间分别为a1,a2,…,a n。
将第i个任务在调度策略中的结束时间记为e i。
请设计一个贪心算法输出这n个任务的一个调度使得用户的平均等待时间1/n∑e i达到最小。
答案要求包含以下内容：（1）证明问题具有贪心选择性；（2）证明问题具有优化子结构；（3）根据贪心选择性和优化子结构用伪代码写出算法；（4）分析算法的时间复杂度（题有问题，1/n∑e i是平均响应时间，不是平均等待时间）答：贪心思想：为了使平均等待时间最短，每次选择执行时间最短的任务。
（1）贪心选择性：不妨设编号为1的任务是n个任务中执行时间最短的，则我们只需要证明有一个最优解是优先执行任务1即可。
那么，设i1,i2,…,i n是一个最优解，则第i j个任务的等待时间为w ij={0 ，j=1e ij−1=∑a ik，j≠1j−1k=1则平均等待时间T为：T=1∑w ijnj=1=1∑e ijn−1j=1=1[(n−1)∙a i1+(n−2)a i2+⋯(n−t)a it+⋯+a in−1]若i1=1，则显然有一个最有解优先执行任务1，若不然，设i t=1，交换i1和i t，得到一个新的解i t,i2,…,i t-1,i1,i t+1,…,i n，这个新解的平均等待时间T`为T`=1∑w ijnj=1=1∑e ijn−1j=1=1n[(n−1)∙a it+(n−2)a i2+⋯(n−t)a i1+⋯+a in−1]由于a i1≥a it，那么，T−T`=(t−1)(a i1−a it)≥0。
由于T是最小的，可知T`=T，新解i t,i2,…,i t-1,i1,i t+1,…,i n也是一个最优解，且a it =a i1=minj=0→na ij。
综上所述，该问题具有贪心选择性。
（2）优化子结构：设i1,i2,…,i n是n个任务的最优解，我们只需要证明i2,…,i n是剩余n-1个任务的最优解。
显然i2,…,i n是子问题的一个最优解，其平均等待时间 T``=1 n−1[(n−2)a i2+⋯(n−t)a it+⋯+a in−1]。
若不然，i2,…,i n不是子问题n-1个任务的最优解，则一定有一个更优的调度j2,…,j n，其平均等待时间T```＜T``，则i1,j2,…,j n显然也是n个任务的解，且其平均等待时间T```` =1[(n−1)∙a i1+(n−2)a i2+⋯(n−t)a it+⋯+a in−1]=1n[(n−1)∙a i1+(n−1)T```]<1n[(n−1)∙a i1+(n−1)T``]=T与i1,i2,…,i n是n个任务的最优解相矛盾，因此i2,…,i n是子问题剩余n-1个任务调度的最优解，该问题具有优化子结构。
（3）算法伪代码：Input：n个任务的时间a[1:n]Output：n个任务的调度A[1:n]Greedy-Min-WaitTime(a)1n←length(a)2create new array A[1:n]3for i←1 to n4do min←∞5 for j←1 to n6 do if a[j]<min7 then min←a[j]8 A[i]←j9 a[A[i]]←∞10 return A（4）时间复杂度分析：算法1~2行时间复杂度为O(1)，3~9行时间复杂度为O(n2)，10行时间复杂度为O(1)。
故算法的时间复杂度为O(n2)。
以上算法是根据贪心思想缩写的，但仔细观察可以发现该问题可等同于将任务按照执行时间大小进行递增排序，排序结果即为该组任务的一个最优调度，因此时间复杂度可降低为排序算法的时间复杂度O(nlogn)。
2. 现有面值为1角、5分、2分、1分的硬币，每种硬币的个数都是无限的。
给出一个贪心算法，使得对任意给定的面值为n(n>18)分的纸币能够将它兑换成币值相等的硬币且使用硬币个数最少。
证明算法的正确性并分析其复杂度。
答：贪心思想：对于给定的面值，每次都取尽可能多的当前可以取到的最大面值硬币。
1角=10分贪心选择性：尽可能多地取当前可取最大面值硬币，即证明当n≥10时，最优解是优先选择一个1角硬币，最优解为x。
若不然，则需选择至少两个5分硬币来替换该1角硬币，x`≥x+1。
以此类推，同理可证当5≤n＜10时，优先选择一个5分硬币，当2≤n＜5时，优先选择一个2分硬币，当n＜2时，选择1分硬币。
优化子结构：该问题显然具有优化子结构，当选择一个面值为m的硬币后，子问题为n-m的硬币兑换问题，仍是选择面值≤n-m的最大面值的硬币。
若不然，子问题有一个更优的解使硬币个数x`-1<x-1，那么加上选择的第一个硬币不等式即可化为x`＜x，与原问题解是最优解相矛盾，因此该问题具有优化子结构。
算法伪代码：Input：兑换面值nOutput：兑换硬币个数xGreedy-Get-Change(n)1 x←n/10+n%10/5+n%10%5/2+n%10%5%22 return x算法的时间复杂度为O(1)。
3.给定k个排好序的有序序列s1,s2, … , s k ,现在用2路归并排序算法对这些有序序列排序。
假定用2路归并排序算法对长度分别为m和n的有序序列排序要用m+n-1次比较操作。
设计一个贪心算法合并s1,s2,…,s k使得所需的比较操作次数最少。
答案要求包含以下内容：（1）证明问题具有贪心选择性；（2）证明问题具有优化子结构；（3）根据贪心选择性和优化子结构用伪代码写出算法；（4）分析算法的时间复杂度。
答：贪心思想：为了使比较操作的次数最少，每次选择长度最小的两个有序序列进行排序，合成一个新的有序序列加入原序列中，直至将k个有序序列合并为一个有序序列为止。
整体思想类似赫夫曼编码，可以将序列的合并用树表示，合并得到的新序列用这两个左右节点的根节点表示。
则显然每个叶节点序列需比较的次数就是这个序列所在树中的编码长度（树的深度，根节点深度为0）。
（1）贪心选择性：不妨设s1,s2为长度最短的两个序列，则只需要证明存在一种最优解，其中执行了s1和s2的合并操作。
设T是一个最优解构成的树，其中s a和s b是具有最大深度的两个兄弟序列节点。
不失一般性，设L(s a)≤L(s b)，L(s1)≤L(s2)。
因为s1和s2是具有最短长度的序列，故有L(s a)≥L(s1)，L(s b)≥L(s2)。
交换T中s a和s1的位置，得到树T`，再交换s b和s2的位置得到树T``。
往证T``是最优解构造的树。
cost(T)−cost(T’)=[∑L(s i)∙d T(i)−(k−1)]ki=1−[∑L(s i)∙d T′(i)ki=1−(k−1)]=L(s a)d T(s a)+L(s1)d T(s1)−L(s a)d T′(s a)−L(s1)d T′(s1)=L(s a)d T(s a)+L(s1)d T(s1)−L(s a)d T(s1)−L(s1)d T(s a)=(L(s a)−L(s1))(d T(s a)−d T(s1))由于L(s a)≥L(s1)，d T(s a) ≥d T(s1)，因此cost(T)-cost(T`)≥0，cost(T)≥cost(T`)。
同理可证cost(T`)≥cost(T``)，于是cost(T)≥cost(T``)。
由于T是最优化的，所以cost(T)≤cost(T``)。
于是cost(T)=cost(T``)，T``也是合并最优解的树。
因此该算法具有贪心选择性。
（2）优化子结构：设T是序列S={s i|0≤i≤k}的一个最优解构成的树，不妨设s x和s y是T中任意连个相邻叶节点，s z是他们的父节点，则s z是长度为L(s z)= L(s x)+L(s y)的字符，T`=T-{s x,s y}是S`=S-{s x,s y}∪s z的优化解构成的树。
往证cost(T)=cost(T`)+L(s x)+ L(s y)-1。
对∀v∈S-{s x,s y}，d T(v)=d T′(v)，L(s v)d T(s v)=L(s v)d T`(s v)。
由于d T(s x)= d T(s y)=d T`(s v)+1，则有L(s x) d T(s x)+L(s y) d T(s y)-1=(L(s x)+L(s y))( d T`(s z)+1)-1=(L(s x)+L(s y)) d T`(s z)+ L(s x)+L(s y)-1= L(s z) d T`(s z)+ L(s x)+L(s y)-1若T`不是S`的最优解，则必存在T``，使cost(T``)<cost(T`)。
因为s z是S`中的序列，则必为T``中的叶子，把节点s x与s y加入T``中，作为s z的子节点，则得到了S的一个新的优化解树T```，那么，cost(T```)=cost(T``)+ L(s x)+L(s y)-1<cost(T`)+ L(s x)+L(s y)-1=cost(T)，与T是优化解矛盾，故T`是S`的优化解树。
（3）算法伪代码Input：k个序列S[1:k]Output：合并最小代价costMin-Merge-Cost(S)1 n←length(S)2 cost←03 Q←S/*用build-heap建立堆*/4 for i←1 to n-15 do z←Allocate-Node()6 x←left[z]←Extract-MIN(Q) /*堆操作*/7 y←right[z]←Extract -MIN(Q) /*堆操作*/ 8 z←Merge (x,y) 9 cost←cost+length(x )+length(y)-1 10 Insert(Q,z) /*堆操作*/ 11 return cost（4）时间复杂度分析：设Q 由一个堆实现，建堆的时间复杂度为O(n)，每个堆操作要求O(logn)，循环n-1次为O(nlogn)。
总的时间复杂度为T(n)= O(n)+ O(nlogn)。
4.给定两个大小为n 的正整数集合A 和B 。
对于A 到B 的一个一一映射f ，不妨设f(a i )=b i （i=1,…,n ），则f 的代价为∑a i b in i=1。
试设计一个贪心算法，找出从A 到B 的代价最大的一一映射。
你的答案应包括：（1）用伪代码写出算法； （2）证明算法的正确性；答：（1）贪心思想：为了得到代价最大的映射，每次选择A ，B 集合中最大的a i 和b i 使得f(a i )=b i ，这样获得的∑a i b in i=1将最大。