算法设计期末复习总结

分治法：

计算方向：自顶向下；

分为3个步骤：

1. divide:整个问题划分为多个子问题；

2. conquer 求解每个子问题

3. combine 合并子问题的解，形成原问题的解

设输入大小为n ，T(n)为时间复杂性，当n

T(n)= aT(n/b)+D(n)+C(n).

1同阶。定义：e(f(n))={g(n)|ЭC1,C2>0,n0;当n>=n0,C1f(n)<=g(n)<=C2f(n)}称为与f(n)同阶。

例题：证明P n a n n i i d

i d ()()===∑0θ,其中a d >0

证:由于)(}m a x {)1(0d d i i d i i n O n a d n a =+≤∑=，

a n a n n i

i d i d d d =∑≥=0Ω()，所以

P n a n n i i d

i d ()()===∑0θ。

2、高阶。定义：Ω（f （n ））={ g(n)|ЭC1,C2>0,n0;当n>=n0,0<=g(n)<=C2f(n)}称为比f(n)高阶。

二分查找：

BinarySearch(max,min,des)

mid-<(max+min)/2

while(min<=max)

mid=(min+max)/2

if mid=des then

return mid

elseif mid >des then

max=mid-1

else

min=mid+1；returnmax O(log n)

归并算法（mergesort）：

输入：A[p,r]：欲排序数据在数组A中。

输出：A[p,r]：排序后的数据。

方法：

Merge-Sort(A,p,r)

if p

q←?(p+r)/2?

Merge-Sort(A,p,q)

Merge-Sort(A,q+1,r)

Merge(A,p,q,r)。

*Merge算法十分简单，需要O(n)次比较。

*若要排序存储在数组A的n个数,只需调用Merge-Sort(A,1,n)。

2.Merge-Sort的分析

·If n=1,T(n)=θ(1)

·Divide阶段的时间复杂性: D(n)= θ(1)

·Conquer阶段的时间复杂性:2T(n

2

)

·Combine阶段的时间复杂性:C(n)=θ(n) θ(1) if n=1

·T(n)=

2T(n/2)+θ(n)+θ(1) if n>1

·使用循环展开法求解T(n)=O(n log n)。

快速排序算法(Quick-Sort):

1.描述：有数组A[p….r]

q=(p+r)/2;

1).divide:把数组A[p…r]划分为两个非空数组A1[p…q],A2[q+1,r];使

得A1中的每个数都小于A2中的；

2).conquer:递归调用排序算法排序A1，A2；

3).combine:将两个已经排好序的算法合并

算法详细:

Quick_sort(A[],p,r)

If p

Then q=partition(A[],p,r)

Quick_sort(A[],p,q)

Quick_sort(a[],q+1,r);

Partition算法:

Partition(a[],p,r)

X=a[p]

i=p-1;

j=r+1;

repaeatj- - until a[j]<=x;

repeat i++ until a[i]>=x;

if i

then exchange a[i] a[j]

else return j;

将数组A有序排序,小的数放在前面

A[i]>=X>=A[j];

最坏时间复杂性:θ(n2)

划分平衡时间复杂性:θ(nlgn)

动态规划技术(Dynamic Programming):

适用：当一个优化问题可以分为多个子问题，子问题的解被重复使用。

满足条件：1.问题据有优化子结构(Optimal substructure)

2.有重叠子问题(Overlapping sub-problems)

优化结构：如果一个问题的优化解包含了他的子问题的优化解，则称该问题据具有优化子结构；

特点：求解每个子问题仅一次，并保存结果，以后用到时直接存取，不重复计算，节省时间。计算方向：自底向上

步骤：

①分析优化解的结构

②递归定义最优解的代价；

③自底向上的计算优化解的代价保存，并获取构造最优解的信息；

④根据构造最优解的信息构造优化解；

●矩阵链乘积(Matrix-chain Multiplication)(~)

优化解的代价方程：

假设：m[I,j]=计算A i-j的最小乘法数=0

；m[i,j]=m[i,k]+m[k+1,j]+p i-1p k p j,

m[i,j]= 0 if i=j

min

i k

I-1

p

k

p

j

} if i

时间复杂性T(n)=0(n3)空间复杂性S(n)=0(n2) ●最长公共子序列问题

步骤：1.问题定义

2.建立求解LCS长度的递归方程

3.LSC长度的计算

4.构造最优解

0-1背包

最优子结构：

(1)问题分析：令f(i,j)表示在前i(0≤i

j(0≤j≤W)的背包中的物品的最大价值，则可以得到如下的动态规划函数:

(2)f[i,j]=0(i=0 OR j=0)

f[i,j]=f[i-1,j] j

f[i,j]=max{f[i-1,j] ,f[i-1,j-wi] +vi } j>wi②

伪代码：

f[0,j]=0

For i=1 to n

For j=0 to W

f[i,j]=max{f[i-1,j] ,f[i-1,j-wi] +vi }

return F[n,W] 问题的解为f[n,W]

Geedy算法

基本思想：1.求解最优化问题的算法包含一些列步骤

2.每一步都有一组选择

3.做出在当前看来最好的选择；

4.希望做出局部优化选择达到全局优化选择

*Greedy算法不一定总产生优化解

Greedy算法产生优化解的条件：1.问题具有优化子结构

2.贪心选择性

贪心选择性：若一个优化问题的全局优化解可以通过局部优化解选择得到。

*Greedy算法与动态规划方法的不同

动态规划：每一步作一个选择—依赖于子问题的解。

Greedy方法:每一步作一个选择—不依赖于子问题的解。

*一个问题是否具有Greedy选择性需要证明。

活动任务安排

GreedyAction(s, f，n) // s[1..n]、f[1..n]分别代表n项活动的起始时间和结束时间, 并且满足f[1]≤ f[2]≤…≤ f[n]

j:=1, solution:={1} //解向量初始化

for i from 2 to n do

if si≥fj then

solution:=solution ∪ {j}; // 将j加入解中

j:=i;

end{if}

end{for}

return(solution);

end{GreedyAction}

时间复杂度：

T(n)=O(n) (排序时)

T(n)=O(nlogn) (未排序时)

3.优化子结构

定义2若一个优化问题的优化解包括它的子问题的优化解，则称其具有优化子结构。

4.与动态规划方法的比较

·动态规划方法可用的条件

①优化子结构

②子问题相交性

③子问题空间小

·Greedy方法可用的条件

①优化子结构

② Greedy选择性

*可用Greedy方法时，动态规划方法可能不适用。

*可用动态规划方法时，Greedy方法可能不适用。

哈夫曼算法：

基本思想：循环的选择具有最低频率的两个节点。生成一颗子树。直至生成一棵树；

算法：Huffman(C，F)

n←|C|;

Q←C;

FOR i←1 To n-1 Do

z←Allocate-Node( );

x←left[z]←Extract-MIN(Q);

y←right[E]←Extract-MIN(Q);

f(z)←f(x)+f(y);

insert(Q,z);

Return Extract-MIN(Q).

时间复杂度：T(n)=O(n)+O(nlogn)

拟阵(Matriod)；

Matroid是一个序对M=(S, I)，满足：

S是一个有限非空集合;

I是非空的S子集的集族，I中的子集合称为S的

独立子集合;

遗传性: 如果B∈I，A?B，则A∈I；

交换性：如果A∈I，B∈I，?A?

得A?{x}∈I。

Matroid的性质

. 1设M=(S，I)是一个Matroid，A∈I。x?A称为A的一个extension 如果A?{x}∈I。

2设M=(S，I)是一个Matroid，A∈I（A称为M的独立子集合）。如果A没有extension，则称A为最大独立子集合。

3一个Matroid的所有最大独立子集合都具有相同大小

4.设M=(S，I)是一个Matroid。如果存在一个权函数W，使得?x∈S,

W(x)是一个正数，则称M是加权Matroid

平摊分析

平摊分析的基本思想

在平摊分析中执行一系列数据结构所需要的时间是通过对执行的所有操作求平

均值而得出的，即使单一操作具有较大的代价，通过对所有求平均后平均代价还是很小的；

平摊分析的方法：聚集方法，势能方法，会计方法；

聚集方法：首先证明n个操作序列在最坏情况下的总时间T(n)

在最坏情况下每个操作的平均代价就是T(n)/n

*聚集方法为每个操作都赋予相同的平摊代价，即使序列中存

在不同类型操作时也一样。

会计方法：·首先定义每个操作的平摊代价然后计算总的平摊代价

·执行不同的操作需要付出不同的费用

·某些操作的费用可能比它们的实际代价多或少

·一个操作的平摊代价可看作为两部分：其实际代价与存款

*会计方法不同于聚集方法，不同操作具有不同的平摊代价。

势能方法:

势能方法不是将已预付的费用作为存储在数据结构特定对象

中的存款来表示，而是表示成一种“势能”，或“势”，它在

需要时可释放出来以支付后面操作的代价。

·势是与整个数据结构而不是其中的个别对象发生联系的。

*每个操作的平摊代价为其实际代价加上由于该操作所增加的势。

第七章近似算法

求解NP-完全问题的两种方法：

·如果问题的输入很小，可以使用指数级算法圆满地解决该问题

·使用多项式算法求解问题的近似优化解

点覆盖：

输入输入：无向图G=（V ，E ）

输出：V V '?，满足

(1).()?∈u v E ,，u V ∈'、v V ∈'或{u,v }?V ’

(2).V '是满足条件(1)的最小集合

APPROX-Vertex-Cover (G)

1.θ←C

2.[]E E G '←

3.while E '≠θ DO

4.任取()u v E ,'∈

5.{}C C u v ← ,

6.

E ’←E ’-{(u ’,v ’)|u ’=u 或v ’=v } 7. Roturn C

2. 时间复杂性T(G)=O(|E|).

第八章

用回溯法解题的三个步骤：

1. 针对所给的问题，定义问题的解空间

2. 确定易于搜索的解空间；

3. 以深度优先的方式搜索解空间，并在搜索过程中用剪枝函数避免无效搜索；

常见的问题解空间分为2种：子集树和排序树。

（1）子集树：在全集里找满足条件的子集，子集树解空间的

复杂度为O(2n) 。

（2）排列树：当所给的问题是确定n个元素满足某种性质的排列时，排列树解空间的复杂度为O(n!)

旅行商问题：TSP-TOUR(G,C)

选择一个r∈V[G]作为生成树的根；2、调用MST-Prim(G,C,r)生成一个最小生成树T；3、先序遍历T，形成有序结点表L；4、按照L中的顺序访问各结点形成哈密顿环。

时间复杂度：T(G)=O(|V|2)。近似比：2