佛山科学技术学院-期末总复习-学长整理-终极版-算法设计与分析

一、递归与分支策略

1.Strassen矩阵乘法是利用分治法实现的算法。

2.使用分治法求解不需要满足的条件是子问题必须是一样的

3.线性时间选择算法：二维：时间复杂度O（n）= n，三维：时间复杂度O（n）= nlogn

4.最接近点对问题算法：时间复杂度O（n）= n2；

5.递推公式求时间复杂度的：用主定理秒杀，见算法ppt第二章，简而言之就是

a)n=log b a compare with f(n)

i.n>f(n),则O（n）= log b a

ii.n=f(n),则O（n）= log b a*logn

6.分治算法的基本步骤包括：分解、解决和合并

二、动态规划

1.最大子段和问题，时间复杂度为n

2.动态规划法的4个步骤设计是什么?

a)找出最优解的性质，并刻画其结构特征

b)递归地定义最优值

c)以自底向上的方式计算出最优值

d)根据计算最优值时得到的信息，构造最优解

3.矩阵连乘(n^3)，最长公共子序列(mn),(m+n),(min{m,n})，凸多边形最优三角剖分(n)，

多边形游戏(n^3)，图像压缩(n)，电路布线(n^2),(n)，流水作业调度(nlogn)，0-1背

包问题(2^n),({2^n,nc})，最优二叉搜索树(n^3)。

4.动态规划算法的两个基本要素

a)最优子结构性质

b)重叠子问题性质

5.用动态规划策略求解最长公共子序列问题：

（1）给出计算最优值的递归方程。

（2）给定两个序列X={B,C,D,A }，Y={A,B,C,B}，请采用动态规划策略求出其最长公共子序列，要求给出过程。

i 0 1 2 3 4

j Y A B C B

0 X 0 0 0 0 0

1 B 0 0 1 1 1

2 C 0 0 1 2 2

3 D 0 0 1 2 2

4 A 0 1 1 2 2

最长公共子序列：｛ＢＣ｝

三、贪心算法

1.基本要素两个

a)贪心选择性质所求问题的整体最优解可以通过一系列局部最优的

选择，即贪心选择来达到

b)最优子结构性质问题的最优解包含了其子问题的最优解

2.活动安排，最优装载，哈夫曼编码，多机调度问题复杂度O（nlogn）

3.单源最短路径复杂度O（n2）

4.最小生成树用Prim算法复杂度O(n2)，用Kruskal算法复杂度O（eloge）。但是当

e=o(n2)时候，Kruskal比Prim好。

5.

四、回溯法

1.装载问题，批处理作业调度，符号三角形，n后，0-1背包，最大团，m着色，旅

行商，圆排列，电路板排列，连续邮资问题

2.回溯法是指：具有限界函数的深度优先生成法

3.回溯法的效率不依赖于哪个因素因素：问题的解空间形式

4.如果解空间树中从根结点到叶结点的最长路径的长度为h(n)，则回溯法所需的计算

空间通常为（O(h(n))）。

5.回溯法的算法框架按照问题的解空间一般分为（子集树）算法框架与（排列树）算

法框架

6.回溯法搜索子集树：

void backtrack (int t)

{

if (t>n) output(x);

else

for (int i=0;i<=1;i++) {

x[t]=i;

if (constraint(t)&&bound(t)) backtrack(t+1);

}

}

7.回溯法搜索排列数：

void backtrack (int t)

{

if (t>n) output(x);

else

for (int i=t;i<=n;i++) {

swap(x[t], x[i]);

if (constraint(t)&&bound(t)) backtrack(t+1);

swap(x[t], x[i]);

}

}

8.

9.回溯法是一种既带有系统性又带有跳跃性的搜索算法

10.回溯法中一个活节点有多次机会成为活节点

11.回溯法有两种策略避免无效搜索。

a)约束函数

b)限界函数

12.同时使用两种策略的是0-1背包问题，只是用约束函数的是N皇后问题

13.回溯法解决0-1复杂度是O（n2n）

14.用回溯法解0/1背包问题时，该问题的解空间结构为（子集树）结构。

15.用回溯法解批处理作业调度问题时，该问题的解空间结构为（排列树）结构。

16.旅行售货员问题的解空间树是（排列树）

17.用回溯法解题通常包含几个步骤？

a)针对所给问题，定义问题的解空间

b)确定易于搜索的解空间结构

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

五、分支限界法

1.单源最短路径，装载，布线，0-1背包，最大团，旅行商，电路板，批作业调度。

2.广度优先或以最小耗费方式搜索问题的解是分支限界法的一搜索方式。

3.两种方法

a)队列式分支限界法

b)优先队列式分支限界法。原则（结点的优先级）

4.简述分支限界法与回溯法的异同点

a)相同点：二者都是一种在问题的解空间树T上搜索问题解的算法。

b)不同点：

[1]求解目标不同。回溯法--所有解，分支限界法--满足约束条件的一个解，

即在某种意义下的最优解。

[2]搜索方式不同，回溯法--深度优先搜索，分支限界法--广度优先

搜索。

[3]对节点存储的常用数据结构以及节点存储特性也各不相同，除由

搜索方式决定的不同的存储结构外，分支限界法通常需要存储一

些额外的信息以利于进一步地展开搜索

[4]拓展节点的拓展方式不同

5.分支限界法解最大团问题时，活结点表的组织形式是最大堆

6.分支限界法解旅行售货员问题时，活结点表的组织形式是最小堆。

7.分支限界法步骤：

a)定义问题的解空间

b)确定易于搜索的解空间结构

c)以广度优先或者代价最小方式搜索解空间，并用剪枝函数避免无效搜索

8.

六、概率算法

1.数值概率算法

就是在算法的过程中引入随机数，使得算法在执行的过程中随机选择下一个计算步骤。

2.舍伍德算法

舍伍德算法总能求得问题的一个解，且所求得的解总是正确的。

当一个确定性算法在最坏情况下的计算复杂性与其在平均情况下的计算复杂性有较大差别时，可以在这个确定算法中引入随机性将它改造成一个舍伍德算法，消除或减少问题的好坏实例间的这种差别。

舍伍德算法精髓不是避免算法的最坏情况行为，而是设法消除这种最坏行为与特定实例之间的关联性。

3.拉斯维加斯算法

拉斯维加斯算法不会得到不正确的解，一旦用拉斯维加斯算法找到一个解，那么这个解肯定是正确的。但是有时候用拉斯维加斯算法可能找不到解。

拉斯维加斯算法得到正确解的概率随着它用的计算时间的增加而提高。对于所求解问题的任一实例，用同一拉斯维加斯算法反复对该实例求解足够多次，可使求解失效的概率任意小。

4.蒙特卡罗算法

用蒙特卡罗算法能求得问题的一个解，但这个解未必是正确的。求得正确解的概率依赖于算法所用的时间。算法所用的时间越多，得到正确解的概率就越高。蒙特卡罗算法的主要缺点就在于此。一般情况下，无法有效判断得到的解是否肯定正确。、

5.舍伍德算法总能求得问题的一个解

6.s为了消除输入数据对程序的影响拉斯维加斯算法对输入进行了预处理

7.数值概率算法常用于数值问题的求解

七、NP完全性理论

1.k带图灵机的空间复杂性S(n)是指k带图灵机处理所有长度为n的输入时，在k条

带上所使用过的方格数的总和。

2.NP类语言在图灵机下的定义为NP={L|L是一个能在多项式时间内被一台NDTM

所接受的语言}；

3.P类语言在图灵机下的定义为P={L|L是一个能在多项式时间内被一台DTM所接受

的语言}

4.P类问题包含在NP类问题中

5.三个基本计算模型

a)RAM

b)RASP

c)TM

八、近似算法

九、算法优化策略

十、在线算法设计

十一、其他

1.算法由若干条指令组成的又穷序列，且满足输入、输出、确定性、有限性四个特性。

2.分支限界法的两种搜索方式有队列式(FIFO)分支限界法、优先队列式分支限界

法，用一个队列来存储结点的表叫活节点表。

3.直接或间接调用自身的方法叫递归算法

4.以广度优先或以最小耗费方式搜索问题解的算法称为分支限界法

5.动态规划的子问题重叠

6.贪心算法的选择性质是贪心选择性质、动态规划法的选择性质是最优子结

构性质。

7.计算一个算法时间复杂度通常可以计算的循环次数、基本操作的频度或计算

步数

8.快速排序算法的性能取决于划分的对称性

9.O的定义：O(g(n)) = { f(n) | 存在正常数c和n0使得对所有n>=n0有：

0<=f(n)<=cg(n) }；

10.Ω的定义：O(g(n)) = { f(n) | 存在正常数c和n0使得对所有n>=n0有：

0<=cg(n)<=f(n) }；

11.任何可用计算机求解的问题所需的时间都与其规模有关

12.程序是算法用某种程序设计语言的具体实现

13.算法是指解决问题的一种方法或一个过程

14.数值概率算法常用于数值问题的求解

15.利用概率的性质计算近似值的随机算法是__数值概率算法

16.渐近上界符号O

17.渐近下界符号Ω

18.紧渐近界符号Θ

19.若线性规划问题存在最优解，它一定不在可行域内部

20.

1,1

()

8(3/7),2

n

f n

f n n n

=

?

=?

+≥

?

这个东西时间复杂度为log7/38简单地说就是log底数为括号里面的倒数，真数为倍数

21.

22.

23.

24.

25.

26.

27.有8个作业{1,2,…,8}要在由2台机器M1和M2组成的流水线上完成加工。每个作

业加工的顺序都是先在M1上加工，然后在M2上加工。M1和M2加工作业i所

给出一个最优调度方案，使得从第一个作业在机器M1上开始加工，到最后一个作业在机器M2上加工完成所需的时间最少，并计算所需的最少时间。

最优调度方案为（6分）

2 7 5 4 8 1 6 3

所需的最少时间为：73 （4分在前一问正确的前提下方可得分）

28.

29.根据优先队列式分支限界法，求下图中从v1点到v9点的单源最短路径，请画出求

得最优解的解空间树。要求中间被舍弃的结点用×标记，获得中间解的结点用单圆

圈○框起（如○v2），最优解用双圆圈◎框起。

12

30.

十二、程序题

1.合并排序

mergeSort(int a[], int left, int right)

{

if(left < right)

{

int i=(left+right)/2;

mergeSort(a, left, I );

mergeSort(a, i+1, right);

merge(a, b, left, i, right);

copy(a, b, left, right);

}

}

2.快速排序

qSort(int a[], int p, int r)

{

if(p

{

int q = parition(a, p, r);

qSort(a, p, q-1);

qSort(a, q+1, r);

}

}

int parition(int a[], int p, int r)

{

int start = p, end = q;

while(start < end )

{

while(start < end && a[start] <= a[end])

{

--end;

}

if(start < end )

{

swap(a[start], a[end] );

++start;

}

while(start < end && a[start] <= a[end])

{

++start;

}

if(start < end)

{

swap(a[start], a[end]);

--end;

}

return start;

}

}

3.贪心算法：背包问题

void Knapsack(int n,float M,float v[],float w[],float x[]) {

Sort（n,v,w）

int i ;

for (i=1;i<=n;i++) x[i]=0;

float c = M;

for (i=1;i<=n;i++)

{

if (w[i]>c) break;

x[i]=1;

c - =w[i];

}

if(i<= n) x[i]=c/w[i];

}

4.贪心算法：活动安排

void GreedySelector(int n, Type s[], Type f[], bool A[]) {

int j=1;

for (int i=2;i<=n;i++) {

if (s[i]>=f[j])

{

j=i;

}

else A[i]=false;

}

}

5.动态规划：最大子段和

int MaxSum(int n, int a[])

{

int sum = 0, b = 0;

for(int j=1； j<=n； j++)

{

if(b>0) b+=a[j];

else b = a[i];

if(b>sum) sum = b;

}

return sum;

}

-----------------------------

int MaxSum(int a[], int left, int right)

{

int sum = 0;

if(left == right)//序列长度为1

{

if(a[left] > 0)

{

sum = a[left];

}

else

{

sum = 0;

}

}

else

{

int center = (left+right)/2;

leftsum = MaxSum(a, left, center);

rightsum = MaxSum(a, center+1, right);

s1 = 0, lefts = 0;

for(I = center; i>=left; --i)

{

lefts += a[i];

if(lefts > s1) s1 = lefts;

}

s2 = 0, rights = 0;

for(j = center+1; j<=right; ++j)

{

rights += a[j];

if(rights > s2) s2 = rights;

}

sum = s1 + s2;

if(sum < leftSum ) sum = leftsum;

if(sum < rightSum ) sum = rightsum;

}

return sum;

}

6.递归：全排列

void perm(Type list[], int k, int m ) { //产生[list[k:m]的所有排列

{ //只剩下一个元素

for (int i=0;i<=m;i++) cout<

cout<

}

else //还有多个元素待排列，递归产生排列

{

swap(list[k]，list[i]);

swap(list[k],list[i]); }

}