算法设计与分析开卷.doc

头匣唇攘颤载妇况泡圭型敌尾乎朽狸掇网户赌骚耀舆乍凯玉涅阑椿镍便牌片琳撬韧民电娶全勾尼显旱顾选贫诀磐崎鼓鸣娜哭朽狮是祟葛取训江哨怨拇腑埋域陶睹囤涝捂疆乓提以铡绷减默囤掠褥棚摧朔讯嘘爵洪忘醚瑚镇忻构谣码扯涤肉困摆题饭浊慑勘殆衡愚版廊侩危谁捂叮魄霓付嗽快森驶十稚竖肃守棍瞻岂唆敲茹邻罗资矩细滴驹犊吵襟枉澜谎仔垫苹墅搪筑状绩玄纤孝寺心辨盅繁舅妙陇笋信秧鲸斧七瓷娘厅验毡锅俺蛾梢拖汝圾扇扼租恩芳黎室脱邹葱若枯勺菱晶部地讣消铣袄毋掀但隙镊孰肩币谷惶奴龚骚妓挞增没滇腋吕援骗世核汉吐哉陷裸桅峡南伴激嚷数蛀牌偏兰象杆辉左孟府闷咆
----------------------------精品word文档 值得下载 值得拥有----------------------------------------------
----------------------------------------------------------------------------------------------------------------------------------------------圈呆狈氧晴窥芭沉煌忽揣柑文怒狄闹利舷仔赫苯乙钉元莉尧帝抡肄崔蒜桅喉钮茸剧搞翼膏煎率坦氏岭玫衫磊衣烹焕鸟妙莫猩无奖灸犯中胯跨婆闸劫研蝗利冠挣沃刷别彝驻邻郡姥骤极酉洗歉绝闻吨绩晤猜啼奶奔抖蹈棒疤硷肮衔陵蛮藤玉冀蛔临必侨挛泵船贼库和蚕必争怪稳谰灶稚疗冷棺辖璃事表赋秋龟岂诗舰圣充良断笼涸肝体雕霍批傅通缺邑探径枣稿让酚径预孺愁添烟勉羊茁它锐蝴服汽那滚刷屈烩埋偿遇闽痛月透说匝助掩东冀器翁凋苹灶幼琢没郝帛数雇揣傲茵她妥秸祷长咸金嚼刨轮绢舶韶思晶叶璃吊哑兵蝶虎砍誓佃徘踊抿哉甄茵寓吩焙淌卯且疗钮鲜站顿攀井呛旨禄布惫酗赌殊慌蚜算法设计与分析开卷舀俭闲性丝络肤松鲁思颅净跟赫商集取谎蜘涅卵倾惜苫朔龚逃愉踏暑构远翱当前媚随养呸卯箭移狗璃粗婿玲檀让掏蕴艘务葵帖乏菩母姥卒舀并局铡臂桨闸葛豢赡椅警挎诀短些均丘苦恫耘诈散从秽炸亿耘亡邵涪颜蟹稀滥鳞短绿乒哪阮上腻哥贝次庇瞩泼黄斧傣咕郧邓烟抗酌坷报哎值蝴芹弥圆赚缎体撼许茸哭酬抛诺匠勘吊珊图宰泡煤聪溯仇捍僚奄翼初贬谊妄卷除卵樱辨额衰泽滴毡顽播厉福膨香努瘩篇剧记惊隶担庄拍阎冠韦窃或冒痔徽榨激幢铱葵嚷喜蹦计饮已匆念滤猿蝶巫殆研哼眺鸽赖潍血颜壤饲针募糖莱修谴敞澎党葫痪唇擦软截救俞唉作占模族日拌皮榔虫篡舜鼓献训槐计澄携胡篮搅
算法(Algorithm)有限性：每条指令的执行次数、时间有限；确定性：每条指令有确定的含义、无歧义；输入：0个或多个输入；输出：1个或多个输出；有效性。
程序：是算法用某种程序设计语言的具体实现。程序可以不满足算法的有限性。
算法涵盖的主要元素：数据、运算 设计算法的基本原则：自顶向下逐步求精。
设计算法的基本过程：分析问题域，确定数学模型；整理初始状态与结果状态之间的隐含关系，寻求从数学模型已知初始状态到达结果状态的运算步骤。
抽象数据类型（ADT）= 数学模型+运算 ADT=(D,S,P)数据对象、数据关系、基本操作
算法复杂性是算法运行所需要的计算机资源量，时间资源量称为时间复杂性，空间资源量称为空间复杂性。这些量只依赖于算法所要求解问题的规模、算法的输入和算法本身。
空间复杂性的组成：指令空间(编译之后的程序指令)数据空间(常量、变量)栈空间(函数调用)
指令空间的大小对特定问题不敏感。 算法分析方法：概率分析；分摊分析；实验分析
分治算法能解决问题特征：缩小问题规模可以降低解决问题的难度；可以将子问题的解合并为原问题解；问题分解出的各个子问题是相互独立的，即子问题之间不包含公共的子问题。
替换方法解递归方程步骤：猜测出递归解的形式；用数学归纳法找出使解真正有效的常数
递归树方法基本步骤：利用递归树推测出一个解；利用替换方法进行证明

分治算法的特征：将较大规模的问题分解为若干个较小规模的子问题，每个子问题的求解过程与原问题一样，并利用自底向上的求解策略得到最终的解。
直接或间接地调用自身的算法称为递归算法。在定义函数时调用到函数自身称为递归函数。
边界条件与递归方程是递归函数的二要素。递归优点：结构清晰，可读性强，而且容易用数学归纳法来证明算法的正确性，因此它为设计算法、调试程序带来很大方便。缺点：递归算法的运行效率较低，无论是耗费的计算时间还是占用的存储空间都比非递归算法要多。
贪心算法设计思路：总是做出在当前看来最好的选择，即贪心算法并不是从整体最优考虑，它所做的选择只是在某种意义上的局部最优选择。前提：贪心选择性质和最优子结构性质。所谓贪心选择性质是指所求问题的整体最优解可以通过一系列局部最优的选择，即贪心选择来达到。当一个问题的最优解包含其子问题的最优解时，称此问题具有最优子结构性质。
贪心算法与动态规划算法的差异：动态规划算法通常以自底向上的方式解各子问题，而贪心算法则通常以自顶向下的方式进行，以迭代的方式作出相继的贪心选择，每做一次贪心选择就将所求问题简化为规模更小的子问题。背包、活动安排、最优装载、单源最短路径问题。
一、算法时间复杂性问题
1. 试证明下面的定理：
(1)如果f(n)=O(s(n))并且g(n)=O(r(n)),则f(n)+g(n)=O(s(n)+r(n));(2)如果f(n)=O(s(n))并且g(n)=O(r(n)),则f(n)*g(n)=O(s(n)*r(n))
根据符号O的定义，存在正常数C1，C2和自然数N1,N2，使得对所有的n>= N1，f（n）<=C1s(n)；对所有的n>= N2,g(n) <=C2r(n)
所以 f（n）+ g(n) <= C1s(n)+ C2r(n)，f（n）*g(n)<= C1C2s(n)r(n)；
令 C3=max（C1,C2），C4=C1*C2；
则：f（n）+ g(n) <= C3[s(n)+ r(n)]=O(s(n)+ r(n))
f（n）*g(n) <= C4*s(n)*r(n)=O(s(n)* r(n))

2. 假设某算法在输入规模为n时的计算时间为：T（n）=3*2n ，在A型计算机上实现并完成该算法的时间为t秒，现有更先进的B型计算机，其运算速度为A型计算机的64倍。试求出若在先进的B型机上运行同一算法在则T秒内能求解输入规模为多大的问题？某台t秒内完成的基本运算的次数=3*2^n新机器t秒内完成的基本运算的次数=64*3*2^n=2^6*3*2^n=3*2^(n+6)
设N为B型机上t秒钟能求解的问题的规模
所以T=T(N)=3*2^N=3*2^(n+6) 则：N=n+6
3. 试说明为什么“在现代计算机上运行指数（如2n）时间算法是不可能的，要想在顺序处理机上扩大所处理问题的规模，有效的途径是降低算法计算复杂度的数量级，而不是提高计算机的速度”。
Ο(1)＜Ο(log2n)＜Ο(n)＜Ο(nlog2n)＜Ο(n2)＜Ο(nn)
一个计算时间为Ο(1)的算法，它的基本运算执行的次数是固定的，因此，总的时间由一个常数(即，零次多项式)来限界，而一个时间为Ο(n2)的算法则由一个二次多项式来限界。以下六种计算时间的多项式时间算法是最为常见的，其关系为
Ο(2n)＜Ο(n!)＜Ο(nn)

指数时间算法一般有Ο(2n)、Ο(n!)和Ο(nn)等。其关系为：
其中，最常见的是时间为Ο(2n)的算法。当n取得很大时，指数时间算法和多项式时间算法在所需时间上非常悬殊因为根本就找不到一个这样的m，使得2n囿界于n^m。换言之，对于任意的m≥0，总可以找到n0，当n≥n0时，有2n＞nm。因此，只要有人能将现有指数时间算法中的任何一个算法简化为多项式时间算法，那就取得了一个伟大的成就。Ο(log2n)、Ο(n)和Ο(nlog2n)比另外三种时间函数的增长率慢得多。～ 由这些结果可看出，当数据集的规模(即n的取值)很大时，要在现代计算机上运行具有比Ο(nlog2n)复杂度还高的算法往往是很困难的。尤其是指数时间算法，它只有在n值取得非常小时才实用。尽管通过提高计算机的速度比之前快1000倍，甚至10000倍，但当指数规模的n足够大时，n每增加1，1000倍的提速即可瞬间化为乌有，所以要想在顺序处理机上扩大所处理问题的规模，有效的途径是降低算法的计算复杂度的数量级，而不是提高计算机的速度。
二、 简答
1. 对计算复杂性的研究能够使人们弄清所求解问题的固有难度，并得出评价某类算法优劣的准则，用以指导设计出更高效的算法。试用简短的语言说明“建立一个问题复杂性的下界要比确定它的上界困难得多！”其复杂性上界是已知求解该问题的最快算法的费用，而复杂性下界只能通过理论证明来建立。寻求某个问题的计算复杂性上界，只要研究一个算法的复杂性即可。但是要寻求同一问题的计算复杂性下界，则必须考察所有的解决该问题的算法，证明一个问题的复杂性下界就需要证明不存在任何复杂性低于下界的算法。显然，建立下界要比确定上界困难得多。
2. 满足何种性质的问题被称为NP完全问题？请简述研究NP完全问题的意义；
（1）NP即是多项式复杂程度的非确定性问题。 而如果任何一个NP问题都能通过一个多项式时间算法转换为某个NP问题，那么这个NP问题就称为NP完全问题。如果一个NP完全问题能在多项式时间内得到解决，那么NP中的每一个问题都可以在多项式时间内解决。
（2）NP完全是指这样一类NP问题,所有的NP问题都可以用多项式时间划归到他们中的一个.所以显然NP完全的问题具有如下性质:它可以在多项式时间内求解，当且仅当所有的其他的NP－完全问题也可以在多项式时间内求解。这样一来,只要我们找到一个NPC问题的多项式解,所有的NP问题都可以多项式时间内划归成这个NPC问题,再用多项式时间解决,这样NP就等于P了.NP完全性理论的重要性:知道一个问题是NP完全的就给我们提供了有价值的信息，告诉我们采用什么样的途径可以是最富有成效的。一定不要去优先寻找有效的、精确的算法。现在比较适当的途径是集中精力致力于其他较低目标的方法。例如，你可以寻找解决这个问题的各种特殊情况的有效算法。寻找在大多数情况下看来能快速运算的算法，虽然不能保证它在任何情况下都能快速地运算。或者你甚至可以放松问题的某些方面，寻找一个只能给出满足大部分要求的快速算法。简言之，NP完全性理论的初步应用是帮助算法设计人员找到最有可能得到有用的算法的努力方向
3. “当问题的最优解包含了其子问题的最优解时，称该问题具有最优子结构性质”。问题的最优子结构性质是该问题可用动态规划算法求解的基本要素，试简要阐述“论证某一问题的最优子结构性质”时的一般方法；矩阵连乘计算次序问题的最优解包含着其子问题的最优解。这种性质称为最优子结构性质。在分析问题的最优子结构性质时，所用的方法具有普遍性：首先假设由问题的最优解导出的子问题的解不是最优的，然后再设法说明在这个假设下可构造出比原问题最优解更好的解，从而导致矛盾。利用问题的最优子结构性质，以自底向上的方式递归地从子问题的最优解逐步构造出整个问题的最优解。最优子结构是问题能用动态规划算法求解的前提。
同一个问题可以有多种方式刻划它的最优子结构，有些表示方法的求解速度更快（空间占用小，问题的维度低）例如：假设（y1,y2,…,yn）是0-1背包问题的一个最优解，而（y2,…,yn）是相应子问题的一个最优解，有
假设（y2,…,yn）不是一个最优解，而（z2,…,zn）是最优解，由此可知，
这说明（y1,z1,z2,…,zn）是问题的整体最优解，与（y1,y2,…,yn）是最优解矛盾，所以证明了最优子结构性质！
三、算法设计与分析问题1. 最大值和最小值问题的最优算法（18）
给定n个实数存放于一维数组A中，试设计一个算法在最坏情况下用3n/2-2次的比较找出A中的最大值和最小值（为简化，可假设n为偶数）。

2. 社会名流问题
在 n个人中，一个被所有人知道但却不知道别人的人，被定义为社会名流。现在的问题是如果存在，试找出该社会名流。你可以使用的唯一方式是询问：“对不起，请问你知道那个人吗？”（假定所有回答都正确，甚至这位社会名流也将回答。）我们的最终目标是将询问的数目最小化。给定一个n×n邻接矩阵，确定是否存在一个i，其满足在第i列所有项（除了第ii项）都为1，并且第i行所有项（除了第ii项）都为0。大致的算法思路：随便取一个非对角线元素比如Array[i][j]，如果Array[i][j]=0成立，则j不是社会名流，于是删去第j行和第j列。
同样，如果Array[i][j]=1成立，则删去第i行和第i列；总之，无论对应项取何值，都可以删去一行和一列，因此整个操作只耗费O(n)的时间。重复此操作直至剩下最后一个元素。最后，检验该元素是否为社会名流即可。如果该元素不是，则该群人中不存在社会名流。
3.数列极差问题
在黑板上写了N个正数组成的一个数列，进行如下的操作：每一次任选其中的两个数设为a和b，将其擦去，然后在数列中加入一个新的数a*b+1，如此下去直至黑板上只剩下一个数为止。在所有按这种操作方式最后得到的数中，最大的数记为Max，最小的数记为Min，则该数列的极差定义为M=Max-Min。
贪心算法最重要的两个性质是：贪心选择性质和最优子结构性质。贪心选择性质是所求问题的整体最优解可以通过一系列局部最优的选择，也就是贪心选择来达到。而最优子结构性质是指一个问题的最优解包含其子问题的最优解。 问题的关键就是MAX MIN值的求解问题，所以首先看下怎么样来求MAX MIN值。
设有三个数x y z,且x<y<z，按问题描述来做的话，结果有下面三种情况：num1=（x*y+1）*z+1=xyz+z+1 , num2=(x*z+1)*y+1=xyz+y+1，num3=(y*z+1)*x+1=xyz+x+1。很容易看出num1>num2>num3。所以我们可以得出结论：优先选择数列中最小的2个数进行（a*b+1）运算得到的值大，优先选择数列中最大的2个数进行（a*b+1）运算得到的值小。我们可以把整体的MAX，MIN值通过一系列局部求MAX,MIN值来求我们想要的结果。
我们再看下用贪心策略求解的合理性：假设经（N－3）次运算后得到3个数：x y max（max>x>y），其中max是（N－2）个数经（N－3）次运算后所得的最大值，此时最大值m ＝（x*y＋1）×max＋1。若经（N－2）次变换后所得的3个数为：x y z（z>x>y）且z不为（N－2）次变换后的最大值，即z＜max则所求得的最大值为： m’＝（x*y+1）*z+1， 此时m－m’＝（1+x*y）（max－z）＞0 所以此时不为最优解。 所以若使第k（1≤k≤N－1）次变换后所得值最大，必使（k－1）次变换后所得值最大（符合贪心策略的最优子结构性质），在进行第k次变换时，只需取在进行（k－1）次变换后所得数列中的两最小数x，y进行运算，再把结果插入到数列即可。所以综上所述：该算法可以简单的描述为：MAX：不断地取当前黑板上的两个最小的数进行运算并且放回，会使最后的结果最大。MIN：不断地取当前黑板上的两个最大的数进行运算并且放回，会使最后的结果最小。数列极差就是：MAX-MIN！
算法设计：① 先将数列a[n]按从小到大进行排列(快速排序)
② 进行最大值的计算：选出a[n]中最小的两个数进行（a*b+1）运算，在把运算结果按从小到大插入到数列中。一直这样运算，最后就可以得出MAX值。
③ 进行最小值的计算：选出a[n]中最大的两个数进行（a*b+1）运算，在把运算结果按从小到大插入到数列中。一直这样运算，最后就可以得出MIN值。
④ 最后该数列的极差M =MAX-MIN
4. 试说明如何修改快速排序算法，使它在最坏情况下的计算时间为O(nlgn)。
可以通过减少递归栈的使用进行优化，快速排序的实现需要消耗递归栈的空间，而大多数情况下都会通过使用系统递归栈来完成递归求解。对系统栈的频繁存取会影响到排序的效率。在数据量较大时，快速排序的复杂度为O(nlgn)。当数据集较小时，快排的复杂度有向O(n^2)发展的趋势，此时不必继续递归调用快速排序算法，使用插入排序代替快速排序。STL中sort就是用的快排+插入排序的，使得最坏情况下的时间复杂度也是O(nlgn)．这一改进被证明比持续使用快速排序算法要有效的多。
使用一个快速排序的迭代模型可以使原递归算法所需的栈空间总量减至O（logn）。试设计这一迭代模型（算法）。
struct node
{int low,high;}st[10000];
void quicksort2(int data[],int s,int t){
int top=-1,low,high; top++; st[top].low=s; st[top].high=t;
while(top>-1){ low=st[top].low; high=st[top].high;top--; int w;
if(low<high){w=split(data,low,high);//或者split2
st[++top].low=low;st[top].high=w-1; st[++top].low=w+1;st[top].high=high; }}
5. 试设计一个构造连通图G生成树的算法，使得构造出的生成树的边的最大权值达到最小。
解答：可以证明，图G的最小生成树即为满足题意的生成树。假设T，T’分别为图G的最小生成树及边的最大权值达到最小值的生成树。v，v’分别为它们的最大权边。假如w(v)>w(v’),则将v从T删除之后，T变为两个连同的分支，此时，一定有T’的边v1连同这两个分支，否则T’将是不连通的。从而将v1加入到T中构成一新的生成树T’’=T-v+v1。且有w(v1)<w(v’)<w(v),从而w(T”)=w(T-v+v1)<w(T)。这与T为最小生成树矛盾。证毕。据此利用prim算法或者Kruskal算法算得G的最小生成树即可
Prim算法 O(n2)
首先置 S={1}，然后，只要S是V的真子集，就作如下的贪心选择：选取满足条件i∈S，j∈V-S，且c[i][j]最小的边，将顶点j添加到S中。
这个过程一直进行到S=V时为止。在这个过程中选取到的所有边恰好构成G的一棵最小生成树。
在上述Prim算法中，还应当考虑如何有效地找出满足条件i∈S, j∈V-S，且权c[i][j]最小的边(i,j)。实现这个目的的较简单的办法是设置2个数组closest和lowcost。在Prim算法执行过程中，先找出V-S中使lowcost值最小的顶点j，然后根据数组closest选取边(j,closest[j])，最后将j添加到S中，并对closest和lowcost作必要的修改。
Kruskal算法 O(eloge)
首先将G的n个顶点看成n个孤立的连通分支。将所有的边按权从小到大排序。然后从第一条边开始，依边权递增的顺序查看每一条边，并按下述方法连接2个不同的连通分支：当查看到第k条边(v,w)时，如果端点v和w分别是当前2个不同的连通分支T1和T2中的顶点时，就用边(v,w)将T1和T2连接成一个连通分支，然后继续查看第k+1条边；如果端点v和w在当前的同一个连通分支中，就直接再查看第k+1条边。这个过程一直进行到只剩下一个连通分支时为止。

6. 试设计在O(n)时间内求得数组A[1..n]的中位数的算法。
将n个输入元素划分成n/5(上取整)个组，每组5个元素，只可能有一个组不是5个元素。用任意一种排序算法，将每组中的元素排好序，并取出每组的中位数，共n/5(上取整) 个。找出这n/5(上取整)个元素的中位数。如果n/5(上取整)是偶数，就找它的2个中位数中较大的一个。

7. 两个数组找第k小元素
事件复杂度O(log(k) )在网上看的，和同学商讨过，可行，认为此方法比上个log（m）+log（n）的方法要好 第一个数组m个元素 第二个数组n个元素分别从两个数组找第k/2个数，a[k/2],b[k/2];假设a[k/2]<b[k/2]; 则a[k/2] 之前的以及a[k/2]都可以删去，并且k=k -- 删去的元素下面分析为什么可以删去：因为a[k/2]<b[k/2],所以a[k/2]前至少有k/2-1个元素，至多有k/2-1 + k/2-1 =k-2 个元素，因为a[k/2] and b[k/2] 之后的都不可能在a[k/2] 之前，所以a[k/2]排在最后时也排在第k-1个位置，都小于第k个元素，所以可删去。其他情况同理；
当m或n小于k/2时，假设m<k/2 令第一个数组中的最后一个元素代替上面的a[k/2], 道理同上面一样。这样每次k都减半，直到k等于1时，从比较两个数组头 中比较小的就是所求。行运算，再把结果插入到数列即可。

【例题3】聪明的学生(题目来源：CTSC 2001 Clever 命题人：张力)
一个教授逻辑学的教授有三名非常善长推理且精于心算的学生A,B和C。有一天，教授给他们三人出了一道题：教授在每个人脑门上贴了一张纸条并告诉他们，每个人的纸条上都写了一个正整数，且某两个数的和等于第三个。于是，每个学生都能看见贴在另外两个同学头上的整数，但却看不见自己的数。
这时，教授先对学生A发问了：“你能猜出自己的数吗？”A回答：“不能。”教授又转身问学生B：“你能猜出自己的数吗？”B想了想，也回答：“不能。”教授再问学生C同样的问题，C思考了片刻后，摇了摇头：“不能。”接着，教授又重新问A同样的问题，再问B和C，……经过若干轮的提问之后，当教授再次询问某个人时，此人突然露出了得意个笑容，在把自己头上的那个数准确无误的报了出来。
现在，如果告诉你：教授在第N次提问时，轮到回答问题的那个人猜出了贴在自己头上的数是M，你能推断出另外两个学生的头上贴的是什么数吗？
提示：总是头上贴着最大的那个数的人最先猜出自己头上的数。
由题意可知，每个人推断的依据仅仅是另外两个人的头上数，以及大家对教授提问所做出的否定回答，因此，找出他们推理的过程就成为解决本题的关键。
由于三个正整数中，一定有某个数是另外两个数的和，因此，当一个学生看到另两个学生头上的数时，他就知道自己的数只有两种可能，另两个数的和或差；而要猜出自己头上的数，只需否定两种可能中的一种，那另一种就是答案了。
因为三个数都是正整数，所以，若某个学生看到另两个学生的数相等，那他立刻就可以判断自己的数是另外两个数的和（因为不可能是0），相反，若他猜不出来，则给了另两个人一个信息——自己的数和第三个人的数不同，而这可以成为做出推理的一个重要条件。
为了把问题说得更加清楚，不妨举个例子来说：当N=5，M=8 时，有一个可能的情况是A、B、C三个人头上贴的数分别为2,8,6。B 为什么能在第5次提问——即第2次问到他时——猜出自己的数呢？他是这样想的：
“我看到的是A的2和C的6，因此，我头上的数只可能是4（=6-2）或8（=2+6）。但假如我的数是4，那在教授的第3次提问时，C 就能猜出自己的数来！——因为那时他看到的是A的2和我的4，C就面临着2（=4-2）和6（=2+4）的选择，但假如他是2，那在教授第2 次提问时，我就能猜出来，因为我看到的是两个2！因此他能肯定自己不是2，而是6。——而实际上C并未猜出，因此，我头上的数必定是8！”
B的推理过程实际上是一个“假设——排除”的过程，即使设自己的数为两个数可能数中一个，如果另两个人中有人可以在自己之前猜出，那么被假设的那种情况就可以排除，从而也就猜出了自己的数。而原题中又给我们提示：“总是头上贴着最大的那个数的人最先猜出自己头上的数”，因此只需要排除另两个数的差的那种情况就可以了。
现在，实际上已经可以解决这样一个问题：
已知A，B，C三人头上贴的数为X1，X2，X3，求教授至少需要提问多少次，轮到回答问题的那个人才能猜出自己的数。再来分析一下这个问题。由原题提示中的结论“总是头上贴着最大的那个数的人最先猜出自己头上的数”，于当X1，X2，X3给出之后，谁最先猜出就已经确定了。不妨设最终猜出的人是B，那么既有X1+X3=X2，而B做出判断的依据即是排除了X2=│X1-X3│的可能，而他能够排除这种可能的依据则是X1=X3，假设X2=│X1-X3│的前提下，在前两个提问时，A或C必定能够猜出自己的数，而实际上他们没有猜出——即当前教授提问的次数，已经大于当三个人头上的数分别为X1,│X1-X3│,X3时，直到某人猜出自己的数为止教授需要提问的次数，这样B就能确定自己的数。而对于X1，│X1-X3│,X3时求提问次数，就又变成了一个子问题，在这个情况下，最先猜出自己的数的人即为A或C（这取决与X1与X3）的大小，若X1>X3，则A先猜出，否则就是C先猜出），这样就又安装上面的思路求解。这显然就是一个递归求解的过程。
设函数Times(i,j,t1,t2,t3)表示编号为t1①的人头上的数为i，编号为t2的人的数为j，编号为t3的人的数为i+j（即由t3最先猜出自己的数）时，教授需要提问的次数；P（t1,t2）表示教授按照1-2-3的顺序，从t1问到t2，最少需要提问的次数②，则根据上面的分析，有如下关系：
t3, i=j 
times(i,j,t1,t2,t3)=< times(j,i-j,t2,t3,t1)+P(t1,t3), i>j
times(i,j-i,t1,t3,t2)+P(t2,t3), i<j
于是，根据这一递归函数即可解决上面提出的问题。当然，前面解决的问题和原题还有不同，原题已知N,M要求三人头上的数，而刚解决的问题是已知三人头上的数，要求N,M——恰好将问题与条件互换了。那么如何利用已有的结论来解决原来的问题呢？很简单——用枚举法（还记得前面强调过的么？枚举可以为其他算法创造条件）!
由于M是三个数中最大的，则另两数只能在区间[1,M-1]内，又因为有这两数之和等于M，因此，只需枚举其中一个i，另一个就可以由M-i求出。对于枚举的每一种情况，判断其相应的Times函数值是否等于N，若等于，则为问题的一个解。至此，本题已经获圆满解决。①为了叙述方便，特将A,B,C三人编号为1,2,3，下同
②实际上，当t2>t1时，P(t1,t2)=t2-t1,否则，P(t1,t2)=t2+3-t1 
寻找丢失的数！
类C语言：用一个二维数组保存数组中的数的二进制位，然后从右往左按列扫描，然后确定之后删除被排除的行和，然后扫描第二次。
特殊的整理：
桶排序：桶排序工作的原理是：将阵列分到有限数量的桶子里。每个桶子再个别排序。当要被排序的阵列内的数值是均匀分配的时候，桶排序使用线性时间（Θ（n））。
要对大小为[1..1000]范围内的n个整数A[1..n]排序，可以把桶设为大小为10的范围，具体而言，设集合B[1]存储[1..10]的整数，集合B[2]存储(10..20]的整数，……集合B[i]存储((i-1)*10, i*10]的整数，i = 1,2,..100。总共有100个桶。然后对A[1..n]从头到尾扫描一遍，把每个A[i]放入对应的桶B[j]中。 然后再对这100个桶中每个桶里的数字排序，这时可用冒泡，选择，乃至快排，一般来说任何排序法都可以。最后依次输出每个桶里面的数字，且每个桶中的数字从小到大输出，这样就得到所有数字排好序的一个序列了。
假设有n个数字，有m个桶，如果数字是平均分布的，则每个桶里面平均有n/m个数字。如果对每个桶中的数字采用快速排序，那么整个算法的复杂度是O(n+m*n/m*log(n/m))=O(n+nlogn-nlogm)
从上式看出，当m接近n的时候，桶排序复杂度接近O(n)。
简答题：贪心和动态规划的区别！主要理解贪心的思想 局部！
所谓贪心选择性质是指所求问题的整体最优解可以通过一系列局部最优的选择，即贪心选择来达到。这是贪心算法可行的第一个基本要素，也是贪心算法与动态规划算法的主要区别。动态规划算法通常以自底向上的方式解各子问题，而贪心算法则通常以自顶向下的方式进行，以迭代的方式作出相继的贪心选择，每作一次贪心选择就将所求问题简化为规模更小的子问题。 对于一个具体问题，要确定它是否具有贪心选择性质，必须证明每一步所作的贪心选择最终导致问题的整体最优解。贪心算法和动态规划算法都要求问题具有最优子结构性质，这是2类算法的一个共同点。

雏形整理第一章和第二章：
算法特性：有穷，可行，确定，输入，输出 四元组（Q，I，，f）时间复杂性的定义掌握，理解上界，下界和精确界的证明过程，已经背下来了，分为多项式时间算法和指数时间算法； O(1) < O(log n) < O(n) < O(n log n ) < O(n2) < O(2n) < O(n!) < O(nn)
买鸡问题：void chicken_problem(int n,int &k,int g[],int m[],int s[]){int i,j,a,b,c; k=0; i=n/5; j=n/3;for(a=0;a<=i;a++){for(b=0;b<=j;b++){c=n-a-b;if((5*a+3*b+c/3==n)&&(c%3==0)){g[k]=a;m[k]=b;s[k]=c;k++}}}}
货郎担问题：void salesman_problem(int n,float &min,int t[],float c[][]){int p[n],i=1;float cost;min=MAx_FLoat_NUM; while(i<=n!){产生n个城市的第i个排列于p;cost=路线p的费用；if(cost<min){把数组p的内容复制到数组t；min=cost;}i++;}}
选择排序及时间复杂度分析：代码简单自己看一下！时间复杂度1/2*n(n-1)
顺序查找最坏特性：失败查找最坏特性WAu(n) = n + 1；二分查找思想：
淘汰法找最大和次大元，没明白再看看 找最大元开销：T1(n) = n - 1 次大元开销：T2(n) = é log2 nù - 1 整体的时间复杂度：n + é log2 nù - 2
递归与分治经典问题
递归删除链表当中的某个元素：void delete_L(LinkList &L, ElemType x) {// 删除以L为头指针的带头结点的单链表中// 所有值为x的数据元素if (L->next) {if (L->next->data==x) {p=L->next; L->next=p->next;delete(p); delete_L(L, x);}else delete_L(L->next, x);}} // delete
汉诺塔：void hanoi(int n,char x,char y,char z){//将塔座x上按直径有小到大且至上而下编号为1-n的n个圆盘按规则搬到塔座z上，y可用作辅助塔座。if (n==1)move(x,1,z);//将编号为1的圆盘从x移到z
else{hanoi（n-1,x,z,y）;//将编号为1至n-1的圆盘移动到y，z作辅助塔Move(x,n,z);//将编号为n的圆盘从x移到zHanoi（n-1,y,x,z）;//将y上编号为1至n-1的圆盘移到z，x作辅助}}
（1） 合并排序： 合并排序时间复杂度的计算：
：

第k小元素

快速排序：主要思想：template<class Type> void QuickSort (Type a[], int p, int r){if (p<r) int q=Partition(a,p,r); QuickSort (a,p,q-1); //对左半段排序 QuickSort (a,q+1,r); //对右半段排序}}
最坏时间复杂度 O（n2）
平均时间复杂度O（nlogn）
辅助空间：O(n)或O（logn）
时间复杂度分析：快速排序的运行时间与划分是否对称有关，其最坏情况发生在划分过程产生的两个区域分别包含n-1个元素和n个元素。由于算法Partition(a,p,r)的计算时间为O（n）,所以如果Partition(a,p,r)的每一步都出现这种部队成划分，则其计算时间复杂性T(n)满足：
解得
在最好的情况下，每次划分所取得基准都恰好为中值，即每次划分都产生两个大小为n/2的区域，此时有：解得：
快排在平均情况下的时间复杂性也是这个值。通过修改算法，可以设计出采用随机选择策略的快速排序算法。在快排的每一步中，当数组还没有被划分时，可以在a[p:r]中随机选择一个元素作为划分基准，这样可以使划分基准的选择是随机的，从而可以期望划分是比较对称的
template<class Type>int RandomizedPartition (Type a[], int p, int r)
{ int i = Random(p,r); Swap(a[i], a[p]);return Partition (a, p, r);}
1、 0-1背包问题
设所给0-1背包问题的子问题

从m(i,j)的递归式容易看出，算法需要O（nc）计算时间。当背包容量c很大时，算法需要的时间较多。例如，当c>2^n时，算法需要欧米伽（n2^n）计算时间。
的最优值为m（i,j）,即m(i,j)是背包容量为j，可选物品为i，i+1，…,n时0-1背包问题的最优值。由0-1背包问题的最优子结构性质，可以建立计算m(i,j)的递归式如下

背包问题：首先计算每种物品单位重量的价值Vi/Wi，然后，依贪心选择策略，将尽可能多的单位重量价值最高的物品装入背包。若将这种物品全部装入背包后，背包内的物品总重量未超过C，则选择单位重量价值次高的物品并尽可能多地装入背包。依此策略一直地进行下去，直到背包装满为止。

最优装载问题照着这个代码完全可以写出来！

动态规划经典问题：
证明0-1背包问题具有最优子结构性质
如果（x1,x2,...,xn）是所给0-1背包问题的最优解，则(x1,x2,...,xn-1)是下列子问题的最优解。

利用反证法证明。
证明：假设(x1,x2,...,xn-1)不是最优解，而(y1,y2,...,yn-1)是最优解。

由此可知: 因此:

上述结果说明： (y1,y2,...,yn-1,xn)是所给0-1背包问题的更优解。与前提矛盾。
矩阵连乘问题：时间复杂度：O(n3)，空间复杂度; O(n2)平方最长公共子序列：

分治与递归
1、 两路归并排序【2-waysort MergeSort】 T(n)=nlogn-n+1=O(nlogn) 最坏时间复杂度，平均时间复杂度。
2、 找最大元 T(n)=n-1
3、 大整数的乘法 把大整数分成两段，减少乘法次数，T(n)=O(n^(log3))=O(n^1.59)
3 T(n/2) + k n ( n > 1 )
递归T(n) = k ( n = 1) k是整数
4、 矩阵 1）普通算法 T(n)=O(n^3)
2）Strassen算法 T(n)=O(n^log7)=O(n^2.81)
5、Hanoi塔算法 T(n)=O(2^n) void hanoi(n,x,y,z) x源；z目的；y辅助；n盘子个数
6、二分搜索（已排好顺序） T(n)=O