南开大学算法导论第六章课件

合集下载

南开大学算法导论第七章课件

Ford-Fulkerson终止时的流有什么性质？
39
最大流与最小割

定理7.9 如果f是使得剩余图Gf中没有s-t 路径的一个s-t流，那么在G中存在一个 s-t割(A*,B*)使得v(f)=(A*,B*).因此，f有 G中任何流的最大值，且(A*,B*)有G中任何s-t割的最小容量。最大流最小割定理. [Ford-Fulkerson 1956] 最大流的值等于最小割
5
最大流问题

1. 2.
流的定义： s-t流是一个函数f,它把每条边e映射到 + E → R 一个非负实数f: ,值f(e)表示由边 e携带的流量，一个流f必须满足下面两个性质： (容量条件)0<=f(e)<=Ce (守恒条件)除了s,t外，对每个结点v,满足 ∑ f ( e ) = ∑ f ( e)
3
7.1 最大流问题
9 9 9

用图对交通网络建模比如公路系统：边是公路，结点交叉路口比如计算机网络：边是链接线，结点是开关比如管网：边是输送些体的管道，结点是管道连接点抽象出来的要素：边上的容量；源点；终点；交通量通过边运送
4
最大流问题

流网络有向图G=(V,E) 每条边关联一个容量，非负数Ce. 存在单一源点s, 以及单一汇点t

42
最大流与最小割
设流f没有增广路径. 定义集合A 是剩余图Gf中从源点s可达顶点集合. 根据定义，那么s ∈ A；终点 t ∉ A, ∈ B. 如果e=(u,v), u∈A,v∈B,那么f(e)=c(e); 如果e’=(u’,v’), u’∈B,v’∈A,那么f(e’)=0.

v( f ) = =
24

C++第六章课件

答当调用一个成员函数时，系统自动产生一个隐藏的指针，
这个指针称为this指针，它始终指向产生这个调用的对象，并将该指针作为一个参数自动传递给该成员函数。这就是说，成员操作符总是要使用的，只不过在对象内是隐式的，而在对象外是显式的。即在对象内省略了this指针。
6.2 this 指针
实际上编译器是这样实现this指针的 1．改变类成员函数的定义，用附加参数this指针来定义每个成员函数。如： void Cgoods::RegisterGoods(Cgoods*this,char*nam, int amount,float price){ strcpy(this->Name,name);this->Amount=amount; this->price=price; } 2．每个类成员函数的调用，加上一个附加的实参——被调用对象的地址。如： Car1.RegisterGoods ( String , number , pr ); 改变为： RegisterGoods ( &Car1 , String , number , pr);
6.1.2 指针变量的赋值、初始化与简单应用
对指针变量决不可以任意赋一个内存地址。指针变量中存放的是在内存中可寻址的变量或对象的首地址，而变量或对象的内存地址是由系统来分配的。程序员不能代替系统给变量分配内存，当然也就不能给指针变量随意赋一个地址值，只能取一个已经分配了内存的变量的地址赋给指针变量。指针中只放变量首地址是不够的，还要知道占多少内存？数据又是怎样组织的？整型数占4 个字节，浮点数占4个字节，字符型占1个字节，宽字符占2个字节；并且它们有各自不同的存储组织方式。
6.2 this 指针
在上例中，this指针不必写成显式的，但是有时必须写成显式的，如在对复数类的赋值号重载中需要返回当前调用的对象时。静态成员函数没有this指针。因为普通成员函数虽然在物理上只有一份拷贝，但在逻辑上都认为一个对象有一份拷贝，所以有this指针，而静态成员函数在逻辑上也只有一份拷贝，不属于具体的对象，当然没有this指针

南开大学

南开大学精品课程立项申请表推荐单位信息技术科学学院课程名称高级语言程序设计课程类型B（院公共基础课）申报类别B（校示范精品课）所属专业名称计算机科学与技术课程负责人刘璟申报日期 2004.2.16南开大学教务处制二ΟΟ 年月日填写要求一、请严格按表中要求如实填写各项。

二、申报表文本中外文名词第一次出现时，要写清全称和缩写，再次出现同一词时可以使用缩写。

纸打印3份，签章后三、请以word文档格式填写表中各栏目，用A4报教务处教学研究科，同时报送软盘。

四、申报类别是指：A.校级精品课程立项项目，或 B.校级示范精品课程立项项目。

1. 课程负责人[1]情况姓名刘璟性别男出生年月1942.6 最终学历研究生职称教授，博导电话23504780 学位硕士职务传真申报级别B.校级示范精品课程申请资助额度 5万元所在院系信息技术科学学院 E-mail jingliu@1-1基本信息通信地址（邮编）天津南开大学信息技术科学学院，3000711-2教学情况近五年来讲授的主要课程（含课程名称、课程类别、周学时；届数及学生总人数）（不超过五门）；承担的实践性教学（含实验、实习、课程设计、毕业论文、毕业设计的年限、学生总人数）；主持的教学研究课题（含课题名称、来源、年限、本人所起作用）（不超过五项）；作为第一署名人在国内外主要刊物上发表的教学相关论文（含题目、刊物名称与级别、时间）（不超过十项）；获得的教学表彰/奖励（含奖项名称、授予单位、署名次序、时间）（不超过五项）。

近五年来讲授的主要课程： 1．高级语言程序设计(本科)，周学时2/4，三届，400－500人。

2．计算机科学概论（本科），周学时3（2周），一届，160人。

3．算法设计与分析(研究生)，周学时3，五届，500－600人。

4．计算机专业英语(研究生)，周学时1，五届，500人。

承担的实践性教学：指导本科生毕业论文 12人（硕、博研究生15人）。

算法导论第三版第六章答案英

算法导论第三版第六章答案英Chapter6Michelle Bodnar,Andrew LohrDecember31,2016Exercise6.1-1At least2h and at most2h+1?1.Can be seen because a complete binarytree of depth h?1hasΣh?1i=02i=2h?1elements,and the number of elementsin a heap of depth h is between the number for a complete binary tree of depth h?1exclusive and the number in a complete binary tree of depth h inclusive.Exercise6.1-2Write n=2m?1+k where m is as large as possible.Then the heap consists of a complete binary tree of height m?1,along with k additional leaves along the bottom.The height of the root is the length of the longest simple path to one of these kleaves,which must have length m.It is clear from the way we de?ned m that m= lg n .Exercise6.1-3If there largest element in the subtee were somewhere other than the root, it has a parent that is in the subtree.So,it is larger than it’s parent,so,the heap property is violated at the parent of the maximum element in the subtreeExercise6.1-4The smallest element must be a a leaf node.Suppose that node x contains the smallest element and x is not a leaf.Let y denote a child node of x.By the max-heap property,the value of x is greater than or equal to the value of y.Since the elements of the heap are distinct,the inequality is strict.This contradicts the assumption that x contains the smallest element in the heap. Exercise6.1-5Yes,it is.The index of a child is always greater than the index of the parent, so the heap property is satis?ed at each vertex. 1Exercise6.1-6No,the array is not a max-heap.7is contained in position9of the array,so its parent must be in position4,which contains6.This violates the max-heap property.Exercise6.1-7It su?ces to show that the elements with no children are exactly indexed by{ n/2 +1,...,n}.Suppose that we had an i in this range.It’s childeren would be located at2i and2i+1but both of these are≥2 n/2 +2>n and so are not in the array.Now,suppose we had an element with no kids,this means that2i and2i+1are both>n,however,this means that i>n/2.This means that i∈{ n/2 +1,...,n}.Exercise6.2-1271731613101571248902717101613315712489027171016138157124830Exercise6.2-2Algorithm1MIN-HEAPIFY(A,i)1:l=LEF T(i)2:r=RIGHT(i)3:if l≤A.heap?size and A[l]4:smallest=l5:else smallest=i6:end if7:if r≤A.heap?size and A[r]8:smallest=r9:end if10:if smallest=i then11:exchange A[i]with A[smallest]12:MIN-HEAPIFY(A,smallest)13:end ifThe running time of MIN-HEAPIFY is the same as that of MAX-HEAPIFY. Exercise6.2-3The array remains unchanged since the if statement on line line8will be false.2Exercise6.2-4If i>A.heap?size/2then l and r will both exceed A.heap?size so the if statement conditions on lines3and6of the algorithm will never be satis?ed. Therefore largest=i so the recursive call will never be made and nothing will happen.This makes sense because i necessarily corresponds to a leaf node,so MAX–HEAPIFY shouldn’t alter the heap.Exercise6.2-5Iterative Max Heapify(A,i)while il=LEFT(i)r=LEFT(i)largest=iif l≤A.heap-size and A[l]>A[i]thenlargest=lend ifif l≤A.heap-size and A[r]>A[i]thenlargest=rend ifif largest=i thenexchange A[i]and A[largest]elsereturn Aend ifend whilereturn AExercise6.2-6Consider the heap resulting from A where A[1]=1and A[i]=2for 2≤i≤n.Since1is the smallest element of the heap,it must be swapped through each level of the heap until it is a leaf node.Since the heap has height lg n ,MAX-HEAPIFY has worst-case time?(lg n).Exercise6.3-1531710841962295317228419610953192284176109584192231761098451922317610984221953176109842219103176593Exercise6.3-2If we had started at1,we wouldn’t be able to guarantee that the max-heap property is maintained.For example,if the array A is given by[2,1,1,3]then MAX-HEAPIFY won’t exchange2with either of it’s children,both1’s.How-ever,when MAX-HEAPIFY is called on the left child,1,it will swap1with3. This violates the max-heap property because now2is the parent of3.Exercise6.3-3All the nodes of height h partition the set of leaves into sets of size between 2h?1+1and2h,where all but one is size2h.Just by putting all the children of each in their own part of trhe partition.Recall from6.1-2that the heap has height lg(n) ,so,by looking at the one element of this height(the root),we get that there are at most2 lg(n) leaves.Since each of the vertices of height h partitions this into parts of size at least2h?1+1,and all but one corresponds to a part of size2h,we can let k denote the quantity we wish to bound,so,(k?1)2h+k(2h?1+1)≤2 lg(n) ≤n/2sok≤n+2h2h+1+2h+1≤n2h+1≤n2h+1Exercise6.4-14513225717208451320257172845252013717284255201371728425132057172842513208717254413208717252520134871725252013178742525513178742202517135874220252135874172025132587417202513852741720254852713172025845271317202587524131720254752813172025745281317202524578131720255427813172025245781317202542578131720252457813172025Exercise6.4-2We’ll prove the loop invariant of HEAPSORT by induction:Base case:At the start of the?rst iteration of the for loop of lines2-5we have i=A.length.The subarray A[1..n]is a max-heap since BUILD-MAX-HEAP(A)was just called.It contains the n smallest elements,and the empty subarray A[n+1..n]trivially contains the0largest elements of A in sorted order.Suppose that at the start of the i th iteration of of the for loop of lines2-5, the subarray A[1..i]is a max-heap containing the i smallest elements of A[1..n] and the subarray A[i+1..n]contains the n?i largest elements of A[1..n]in sorted order.SinceA[1..i]is a max-heap,A[1]is the largest element in A[1..i]. Thus it is the(n?(i?1))th largest element from the original array since the n?i largest elements are assumed to be at the end of the array.Line3swaps A[1]with A[i],so A[i..n]contain the n?i+1largest elements of the array, and A[1..i?i]contains the i?1smallest elements.Finally,MAX-HEAPIFY is called on A,1.Since A[1..i]was a max-heap prior to the iteration and only the elements in positions1and i were swapped,the left and right subtrees ofnode1,up to node i?1,will be max-heaps.The call to MAX-HEAPIFY will place the element now located at node1into the correct position and restore the5max-heap property so that A[1..i?1]is a max-heap.This concludes the next iteration,and we have veri?ed each part of the loop invariant.By induction, the loop invariant holds for all iterations.After the?nal iteration,the loop invariant says that the subarray A[2..n] contains the n?1largest elements ofA[1..n],sorted.Since A[1]must be the n th largest element,the whole array must be sorted as desired.Exercise6.4-3If it’s already sorted in increasing order,doing the build max heap-max-heap call on line1will takeΘ(n lg(n))time.There will be n iterations of the for loop, each takingΘ(lg(n))time because the element that was at position i was the smallest and so will have lg(n) steps when doing max-heapify on line5.So, it will beΘ(n lg(n))time.If it’s already sorted in decreasing order,then the call on line one will only takeΘ(n)time,since it was already a heap to begin with,but it will still take n lg(n)peel o?the elements from the heap and re-heapify.Exercise6.4-4Consider calling HEAPSORT on an array which is sorted in decreasing order. Every time A[1]is swapped with A[i],MAX-HEAPIFY will be recursively called a number of times equal to the height h of the max-heap containing the elements of positions1through i?1,and has runtime O(h).Since there are2k nodes at height k,the runtime is bounded below bylg ni=12i log(2i)=lg ni=1i2i=2+( lg n ?1)2 lg n =?(n lg n).Exercise6.4-5Since the call on line one could possibly take only linear time(if the input was already a max-heap for example),we will focus on showing that the for loop takes n log n time.This is the case because each time that the last element is placed at the beginning to replace the max element being removed,it has to go through every layer,because it was already very small since it was at the bottom level of the heap before.Exercise6.5-1The following sequence of pictures shows how the max is extracted from the heap.1.Original heap:615 13540126298172.we move the last element to the top of theheap 3.13>9>1so,we swap1and13.4.Since12>5>1,we swap1and12.75.Since6>2>1,we swap1and6.Exercise6.5-2The following sequence of pictures shows how10is inserted into the heap, then swapped with parent nodes until the max-heap property is restored.The node containing the new key is heavily shaded.1.Original heap:815 13540126298172.MAX-HEAP-INSERT(A,10)is called,so we?rst append a node assignedvalue?∞:3.The key value of the new node is updated:4.Since the parent key is smaller than10,the nodes are swapped:95.Since the parent node is smaller than10,the nodes are swapped:Exercise6.5-3Heap-Minimum(A)1:return A[1]Heap-Extract-Min(A)1:if A.heap-size<1then2:Error“heap under?ow”3:end if4:min=A[1]5:A[1]=A[A.heap?size]6:A.heap?size??7:Min-heapify(A,1)8:return minHeap-decrease-key(A,i,key)101:if key?A[i]then2:Error“new key larger than old key”3:end if4:A[i]=key5:while i>1and A[P arent(i)]6:exchange A[i]with A[P arent(i)]7:i=P arent(i)8:end whileMin-Heap-Insert(A,key)1:A.heap?size++2:A[A.heap?size]=∞3:Heap-Decrease-Key(A,A.heap-size,key)Exercise6.5-4If we don’t make an assignment to A[A.heap?size]then it could contain any value.In particular,when we call HEAP-INCREASE-KEY,it might be the case that A[A.heap?size]initially contains a value larger than key,causing an error.By assigning?∞to A[A.heap?size]we guarantee that no error will occur.However,we could have assigned any value less than or equal to key to A[A.heap?size]and the algorithm would still work.Exercise6.5-5Initially,we have a heap and then only change the value at i to make it larger.This can’t invalidate the ordering between i and it’s children,the only other thing that needs to be related to i is that i is less than it’s parent,which may be false.Thus we have the invariant is true at initialization.Then,when we swap i with its parent if it is larger,since it is larger than it’s parent,it must also be larger than it’s sibling,also,since it’s parent was initially above its kids in the heap,we know that it’s parent is larger than it’s kids.The only relation in question is then the new i and it’s parent.At termination,i is the root,so it has no parent,so the heap property must be satis?ed everywhere.Exercise6.5-6Replace A[i]by key in the while condition,and replace line5by“A[i]= A[P ARENT(i)].”After the end of the while loop,add the line A[i]=key. Since the key value doesn’t change,there’s no sense in assigning it until we know where it belongs in the heap.Instead,we only make the assignment of the parent to the child node.At the end of the while loop,i is equal to the position where key belongs since it is either the root,or the parent is at least11key,so we make the assignment.Exercise6.5-7Have a?eld in the structure that is just a count of the total number of elements ever added.When adding an element,use thecurrent value of that counter as the key.Exercise6.5-8The algorithm works as follows:Replace the node to be deleted by the last node of the heap.Update the size of the heap,then call MAX-HEAPIFY to move that node into its proper position and maintain the max-heap property. This has running timeO(lg n)since the number of times MAX-HEAPIFY is recursively called is as most the height of the heap,which is lg n . Algorithm2HEAP-DELETE(A,i)1:A[i]=A[A.heap?size]2:A.heap?size=A.heap?size+13:MAX-HEAPIFY(A,i)Exercise6.5-9Construct a min heap from the heads of each of the k lists.Then,to?nd the next element in the sorted array,extract the minimum element(in O lg(k) time).Then,add to the heap the next element from the shorter list from which the extracted element originally came(also O(lg(k))time).Since?nding the next element in the sorted list takes only at most O(lg(k))time,to? nd the whole list,you need O(n lg(k))total steps.Problem6-1a.They do not.Consider the array A= 3,2,1,4,5 .If we run Build-Max-Heap,we get 5,4,1,3,2 .However,if we run Build-Max-Heap’,we will get 5,4,1,2,3 instead.b.Each insert step takes at most O(lg(n)),since we are doing it n times,weget a bound on the runtime of O(n lg(n)).Problem6-2a.It will su?ce to show how to access parent and child nodes.In a d-ary array,PARENT(i)= i/d ,and CHILD(k,i)=di?d+1+k,where CHILD(k,i) gives the k th child of the node indexed by i.12b.The height of a d-ary heap of n elements is with1of log d n.c.The following is an implementation of HEAP-EXTRACT-MAX for a d-aryheap.An implementation of DMAX-HEAPIFY is also given,which is the analog of MAX-HEAPIFY for d-ary heap.HEAP-EXTRACT-MAX con-sists of constant time operations,followed by a call to DMAX-HEAPIFY.The number of times this recursively calls itself is bounded by the height of the d-ary heap,so the running time is O(d log d n).Note that the CHILD function is meant to be the one described in part(a).Algorithm3HEAP-EXTRACT-MAX(A)for a d-ary heap1:if A.heap?size<1then2:error“heap under?ow”3:end if4:max=A[1]5:A[1]=A[A.heap?size]6:A.heap?size=A.heap?size?17:DMAX-HEAPIFY(A,1)Algorithm4DMAX-HEAPIFY(A,i)1:largest=i2:for k=1to d do3:if CHILD(k,i)≤A.heap?size and A[CHILD(k,i)]>A[i]then4:if A[CHILD(k,i)]>largest then5:largest=A[CHILD(k,i)]6:end if7:end if8:end for9:if largest=i then10:exchange A[i]with A[largest]11:DMAX-HEAPIFY(A,largest)12:end ifd.The runtime of this implementation of INSERT is O(log d n)since the whileloop runs at most as many times as the height of the d-ary array.Note that when we call PARENT,we mean it as de?ned in part(a).e.This is identical to the implementation of HEAP-INCREASE-KEY for2-aryheaps,but with the PARENT function interpreted as in part(a).The run-time is O(log d n)since the while loop runs at most as many times as the height of the d-ary array.13Algorithm5INSERT(A,key)1:A.heap?size=A.heap?size+12:A[A.heap?size]=key3:i=A.heap?size4:while i>1and A[P ARENT(i)5:exchange A[i]with A[P ARENT(i)]6:i=P ARENT(i)7:end whileAlgorithm6INCREASE-KEY(A,i,key)1:if key2:error“new key is smaller than current key”3:end if4:A[i]=key5:while i>1and A[P ARENT(i)6:exchange A[i]with A[P ARENT(i)]7:i=P ARENT(i)8:end whileProblem6-3a.2345 891214 16∞∞∞∞∞∞∞b.For every i,j,Y[1,1]≤Y[i,1]≤Y[i,j].So,if Y[1,1]=∞,we know thatY[i,j]=∞for every i,j.This means that no elements exist.If Y is full,it has no elements labeled∞,in particular,the element Y[m,n]is not labeled ∞.c.Extract-Min(Y,i,j),extracts the minimum value from the young tableau Yobtained by Y [i ,j ]=Y[i +i?1,j +j?1].Note that in running this algorithm,several accesses may be made out of bounds for Y,de? ne these to return∞.No store operations will be made on out of bounds locations.Since the largest value of i+j that this can be called with is n+m,and this quantity must increase by one for each call,we have that the runtime is bounded by n+m.d.Insert(Y,key)Since i+j is decreasing at each step,starts as n+m and isbounded by2below,we know that this program has runtime O(n+m). e.Place the n2elements into a Young Tableau by calling the algorithm frompart d on each.Then,call the algorithm from part c n2to obtain the numbers in increasing order.Both of these operations take time at most2n∈O(n), and are done n2times,so,the total runtime is O(n3)141:min=Y[i,j]2:if Y[i,j+1]=Y[i+1,j]=∞then3:Y[i,j]=∞4:return min5:end if6:if Y[i,j+1]7:Y[i,j]=Y[i,j+1]8:Y[i,j+1]=min9:return Extract-min(y,i,j+1)10:else11:Y[i,j]=Y[i+1,j]12:Y[i+1,j]=min13:return Extract-min(y,i+1,j)14:end if1:i=m,j=n2:Y[i,j]=key3:while Y[i?1,j]>Y[i,j]or Y[i,j?1]>Y[i,j]do 4:if Y[i?1,j]5:Swap Y[i,j]and Y[i,j?1]6:j??7:else8:Swap Y[i,j]and Y[i?1,j]9:i??10:end if11:end while15f.Find(Y,key).Let Check(y,key,i,j)mean to return true if Y[i,j]=key,oth-erwise do nothingi=j=1while Y[i,j]Check(Y,key,i,j)i++end whilewhile i>1and jCheck(i,j)if Y[i,j]j++elsei–end ifend whilereturn false16。

算法导论详解PPT课件

computing
“计算机算法的圣经”
Bibliography
《Introduction to Algorithms》(Second Edition),
T. H. Cormen, C. E. Leiserson, R. L. Rivest (2002, Turing Award),
The MIT Press
}
利用此界面使方法sum通用化
18
第18页/共25页
1.3 描述算法
6.通用方法
（2）parable 界面 Java的Comparable 界面中惟一的方法头compareTo用于比较
2个元素的大小。例如pareTo(y) 返回x-y的符号，当x<y时返回负数，当x=y时返回0，当x>y时返回正数。（3）Operable 界面
8
第8页/共25页
1.2 表达算法的抽象机制
2.抽象数据类型
抽象数据类型是算法的一个数据模型连同定义在该模型上并作为算法构件的一组运算。
抽象数据类型带给算法设计的好处有：
（1）算法顶层设计与底层实现分离；（2）算法设计与数据结构设计隔开，允许数据结构自由选择；（3）数据模型和该模型上的运算统一在ADT中，便于空间和时间耗费的折衷；（4）用抽象数据类型表述的算法具有很好的可维护性；（5）算法自然呈现模块化；（6）为自顶向下逐步求精和模块化提供有效途径和工具；（7）算法结构清晰，层次分明，便于算法正确性的证明和复杂性的分析。
期末闭卷考试：
about 70%
课程安排
课堂讲解：基本理论讲解，基本方法的介绍分析
上机实践：基本习题和经典习题的上机实践
第4页4 /共25页
主要内容介绍

2018届高考数学理科全国通用一轮总复习课件：第六章不等式、推理与证明 6-5 精品

第五节直接证明与间接证明
【知识梳理】 1.直接证明
内容
综合法
分析法
从已知条件出发,经从待证结论出发,一步一步寻
过逐步的推理,最后求结论成立的充分条件,最后
定达到待证结论的方达到题设的已知条件或已被
义法,是一种从_原__因__ 证明的事实的方法,是一种从
推导到_结__果__的思维 _结__果__追溯到产生这一结果的
因为A1D1⊂平面A1BD1,D1B⊂平面 A1BD1,A1D1∩D1B=D1, 所以平面A1BD1∥平面ADC1, 因为A1B⊂平面A1BD1,所以A1B∥平面ADC1.
【加固训练】
1.(2016·枣庄模拟)设a,b,c>0,证明:a2 b2 c2 a b c.
bca
【证明】因为a,b,c>0,根据基本不等式,
只需证a2+13a+42>a2+13a+40,只需证42>40, 因为42>40成立,所以P>Q成立.
感悟考题试一试
2.(2016·滨州模拟)用反证法证明命题“若a,b∈N,ab
可被5整除,那么a,b中至少有一个能被5整除”时,假设
的内容应该是 ( )
A.a,b都能被5整除
B.a,b都不能被5整除
C.a,b不都能被5整除
D.a能被5整除
【解析】选B.“至少有一个能被5整除”的反面是“都不能被5整除”.
3.(2016·菏泽模拟)设a=lg2+lg5,b=ex(x<0),则a与b
的大小关系为 ( )
A.a>b
B.a<b
C.a=b
D.a≤b
【解析】选A.因为a=lg2+lg5=lg10=1,而b=ex<e0=1,

算法导论课件5

analysis: n2 multiplications and at most n2-1 additions (加法). So, T(n)=O(n2).
6

Exam2 Multiplication of two numbers （整数相乘） two n-digit numbers X and Y, Complexity(X × Y) = ? � Divide and Conquer algorithm Let X=ab Y=cd where a, b, c and d are n/2 digit numbers, e.g. 1364=13×102+64. Let m= n/2. Then XY = (10ma+b)(10mc+d) =102mac+10m(bc+ad)+bd
11

Exam3 Multiplication of two matrices （矩阵相乘） two n×n matrices A and B, Complexity(C=A×B) = ?
�
Divide and conquer (Strassen Algorithm) An n×n matrix can be divided into four n/2×n/2 matrices, ⎡ A11 A12 ⎤ ⎡ B11 B12 ⎤ ⎡ C11 C12 ⎤ A= ⎢ ,B= ⎢ ,C= ⎢ ⎥ ⎥ ⎥ ⎣A 21 A 22 ⎦ ⎣B21 B22 ⎦ ⎣C21 C 22 ⎦
12
Complexity analysis: Totally, 7 multiplications, and 18 additions. T(1)=1, T(n) = 7T( ⎡n/2⎤ )+ cn2. Applying Master Theorem,

a12-chap16(1)-Greedy 算法导论教学课件

11 10
9 8 7 6 5 4 3 2 1
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
9

16.1.1 Optimal substructure of activity selection
if f0 ≤ f1 ≤ f2 ≤ · · · ≤ fn < fn+1 (if i ≤ j, then fi ≤ fj) (16.1) Then i ≥ j ⇒ Sij =
Theorem 16.1 Let Sij ≠ , and let am be the activity in Sij with the earliest finish time: fm = min {fk : ak ∈ Sij }. Then
1. am is used in some maximum-size subset of mutually compatible activities of Si j .（am 包含在某个最大相容活动子集中）
Space of subproblems Sij = {ak ∈ S : fi ≤ sk < fk ≤ s j }
Assume that activities are sorted by monotonically increasing finish time （以结束时间单调增的方式对活动进行排序） f0 ≤ f1 ≤ f2 ≤ · · · ≤ fn < fn+1 (if i ≤ j, then fi ≤ fj) (16.1)
For many optimization problems, using dynamic programming to determine the best choices is overkill.

chapter6简要.ppt

•无序树：树中结点的各子树从左至右是无次序的,可以互换的树
•森林：是n(n>=0)棵互不相交的树的集合
6.2二叉树
1.定义
二叉树:是一种特殊类型的树 •树中每个结点至多只有两棵子树 •子树有左右之分,分别称为左子树和右子树
2.二叉树的性质
性质1. 在二叉树的第i层上至多有2i-1个结点(i>=1)
TElemType data; struct BitNode *lchild, *rchild, *parent; }BiTNode,*BiTree;
6.3遍历二叉树和线索二叉树
一.遍历二叉树 1.遍历二叉树的操作定义
是指按某条搜索路径巡访树中每个结点,使得每个结点均被访问一次,而且仅被访问一次.
层次遍历：ABCDEFGH
3.遍历的递归定义和递归实现
先序遍历的递归定义：若二叉树不为空，则：（1）访问根结点（2）先序遍历左子树（3）先序遍历右子树
先序遍历的递归实现： Status PreOrderTraverse(BiTree T){
if(T){ Visit(T->data); if(T->lchild) PreOrderTraverse(T->lchild); if(T->rchild) PreOrderTraverse(T->rchild);
用二叉树表示表达式,二叉树的先序、中序、后序遍历的结果分别对应于表达式的前缀（波兰式）、中缀和后缀表示（逆波兰式）.
例 a+b*(c-d)-e/f
-
+
/
a
*e
f
b
-
先序遍历中序遍历后序遍历
c
d
-+a*b-cd/ef a+b*c-d-e/f abcd-*+ef/-

算法分析与设计常见算法思想

算法分析与设计常见算法思想。

算法导论复习——常见算法思想PPT2-1：1.堆排序（选择类排序，不稳定）（1）初始化操作：将R[1..n]构造为初始堆；（2）每⼀趟排序的基本操作：将当前⽆序区的堆顶记录R[1]和该区间的最后⼀个记录交换，然后将新的⽆序区调整为堆（亦称重建堆）。

时间复杂度是：O（nlgn）2.归并排序)归并排序采⽤分治法思想的稳定的排序。

算法思想是先使每个⼦序列有序，再使⼦序列段间有序。

第⼀步：申请空间，使其⼤⼩为两个已经排序序列之和，该空间⽤来存放合并后的序列第⼆步：设定两个指针，最初位置分别为两个已经排序序列的起始位置第三步：⽐较两个指针所指向的元素，选择相对⼩的元素放⼊到合并空间，并移动指针到下⼀位置重复步骤3直到某⼀指针超出序列尾，将另⼀序列剩下的所有元素直接复制到合并序列尾。

时间复杂度是：O（nlgn）3.快速排序（交换类排序，不稳定）|（1）通过⼀趟排序将要排序的数据分割成独⽴的两部分，其中⼀部分的所有数据都⽐另外⼀部分的所有数据都要⼩；（2）然后再按此⽅法对这两部分数据分别进⾏快速排序，整个排序过程可以递归进⾏，以此达到整个数据变成有序序列。

时间复杂度是：O（nlgn）。

4.分治法实现⼤数相乘将a，b写成前⼀半数字和后⼀半数字相加的形式，例如若 a = 5423678，那么a1 = 542，a0 = 3678（注意若不是偶数截取较⼩⼀半）这样a和b相乘就可以写为：a * b = { a1 * 10^(n1/2) + a0 } * { b1 * 10^(n 2/2) + b0 }（展开后整理得：a *b = a1*b1 * 10^[ (n1+n2)/2 ] + a1*b0 * 10^(n1/2 ) + a0*b1 * 10^(n2/2) + a0*b0 四项这样就很容易递归的来求a * b，如果你嫌分解后的数还太⼤，就可以继续分解。

（你可以⾃⼰规定在何时结束递归）时间复杂度是：O（nlgn）参考资料见：5.分治法求最近点对步骤⼀：找⼀条中垂线m(坐位S集合x坐标的中位数)把n个元素分成左右两部分元素，步骤⼆：递归查找两边点集的的最短距离d1,d2，然后取两者中的最⼩者记为d；步骤三：在中线两边分别取d的距离，记录该距离范围内点的个数，中线左边有L个元素，右边有R个元素，分别将两边的点按y坐标升序排列，在左边集合中每⼀个点，找右边集合的点，找到与之距离⼩于d的点，更新最短距离，直到循环结束，即可求出最短距离。

算法导论CN2nd第六章堆排序6寸kindle版

第6章堆排序本章要介绍另一种排序算法，即堆排序（heapsort）。

像合并排序而不像插入顺序，堆排O n n。

像插入排序而不像合序的运行时间为(lg)并排序，它是一种原地（inplace）排序算法：在任何时候，数组中只有常数个元素存储在输入数组以外。

这样，堆排序就把我们讨论过的两种排序算法的优点结合起来。

堆排序还引入另一种算法设计技术：利用某种数据结构（在此算法中为“堆”）来管理算法执行中的信息。

堆数据结构不只是在堆排序中有用，还可以构成一个有效的优先队列。

堆数据结构在后续章节的算法中还将重复出现。

“堆”这个词最初是在堆排序中提出的，但后来就逐渐指“废料收集存储区”，就像程序设计语言Lisp 和Java中所提供的设施那样。

我们这里的堆数据结构不是废料收集存储区；本书中以后任何地方提到堆结构，都是指本章定义的结构。

6.1 堆（二叉）堆数据结构是一种数组对象，如图6-1所示，它可以被视为一棵完全二叉树（见B.5.3节）。

树中每个结点与数组中存放该结点值的那个元素对应。

树的每一层都是填满的，最后一层可能除外（最后一层从一个结点的左子树开始填）。

表示堆的数组A是—个具有两个属性的对象；A.length是数组中的元素个数，A.heap-size 是存放在A 中的堆的元素个数。

就是说，虽然从A[1..A.length]中都可以包含有效值，但A[A.heap-size]之后的元素都不属于相应的堆，此处.A heap size −≤.A length 。

树的根为A[1]，给定了某个结点的下标i，其父结点PARENT（i）、左儿子LEFT（i）和右儿子RIGHT（i）的下标可以简单地计算出来： PARENT(i)1 return /2i ⎢⎥⎣⎦LEFT(i)1 return 2iRIGHT(i)1 return 2i+1图6-1一个最大堆（大根堆）可被看作a）一棵二叉树和b）—个数组。

圆圈中的数字表示树中每个结点存储的值，结点上方的数宇表示对应的数组下标。