算法设计与分析复习题整理 (1)

一、基本题：
算法：
1、程序是算法用某种程序设计语言的具体实现。

2、算法就是一组有穷的序列(规则) ，它们规定了解决某一特定类型问题的一系
列运算。

3、算法的复杂性是算法效率的度量，是评价算法优劣的重要依据。

4、算法的“确定性”指的是组成算法的每条指令是清晰的，无歧义的。

5、算法满足的性质：输入、输出、确定性、有限性。

6、衡量一个算法好坏的标准是时间复杂度低。

7、算法运行所需要的计算机资源的量，称为算法复杂性，主要包括时间复杂性和
空间复杂性。

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

递归与分治：
9、递归与分治算法应满足条件：最优子结构性质与子问题独立。

10、分治法的基本思想是首先将待求解问题分解成若干子问题。

11、边界条件与递归方程是递归函数的两个要素。

12、从分治法的一般设计模式可以看出，用它设计出的程序一般是递归算法。

13、将一个难以直接解决的大问题，分解成一些规模较小的相同问题，以便各个击
破。

这属于分治法的解决方法。

14、Strassen矩阵乘法是利用分治策略实现的算法。

15、大整数乘积算法是用分治法来设计的。

16、二分搜索算法是利用分治策略实现的算法。

动态规划：
17、动态规划算法的两个基本要素是最优子结构性质和重叠子问题性质。

18、下列算法中通常以自底向上的方式求解最优解的是动态规划法。

19、备忘录方法是动态规划算法的变形。

20、最优子结构性质是贪心算法与动态规划算法的共同点。

21、解决0/1背包问题可以使用动态规划、回溯法，其中不需要排序的是动态规
划，需要排序的是回溯法。

贪心算法：
22、贪心算法总是做出在当前看来最好的选择。

也就是说贪心算法并不从整体
最优考虑，它所做出的选择只是在某种意义上的局部最优解。

23、最优子结构性质是贪心算法与动态规划算法的共同点。

24、背包问题的贪心算法所需的计算时间为 O(nlogn) 。

回溯法：
25、回溯法中的解空间树结构通常有两种，分别是子集树和排列树。

（3）
26、回溯法搜索解空间树时，常用的两种剪枝函数为约束函数和限界函数。

27、解决0/1背包问题可以使用动态规划、回溯法，其中不需要排序的是动态规
划，需要排序的是回溯法。

28、使用回溯法进行状态空间树裁剪分支时一般有两个标准：约束条件和目标函数
的界，N皇后问题和0/1背包问题正好是两种不同的类型，其中同时使用约束条件和目标函数的界进行裁剪的是 0/1背包，只使用约束条件进行裁剪的是 N 皇后问题。

29 用搜索算法解旅行售货员问题时的解空间树是排列树。

30 回溯法搜索状态空间树是按照深度优先遍历的顺序。

31、回溯法算法是以深度优先策略进行搜索的。

32、0-1背包问题的回溯算法所需的计算时间为 O（n2n）
分支限界法：
33、以广度优先搜索或以最小耗费（最大效益）优先的方式搜索问题解的算法称
为分支限界法。

34、分支限界法主要有队列式（FIFO）分支限界法和优先队列式分支限界法。

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

其他：
36、10000*n^2+10*n+1的时间复杂度是______。

37、f(n)=n^2+10*n+1000000的时间复杂度是______。

38、算法分析中,记号O表示渐进上界。

39、f(n)= 6×2n+n2，f(n)的渐进上界是 O(2^n)。

40、f(n)= 6×2n+n2，f(n)的渐进上界是 O(n^2)。

41、f(n)= 100×3n+10000×n2，f(n)的渐进上界是_____________。

42、f(n)= 6×4n+n2，f(n)的渐进上界是 O(2^n) 。

43、按照渐近阶从低到高的顺序排列下列表达式：4n2，logn，3n， n2/3，n!，2n。

Logn< n2/3<4n2<2n<3n<n! 。

1、下列不是动态规划算法基本步骤的是（A）。

A、找出最优解的空间结构
B、构造最优解
C、算出最优解
D、定义最优解
2、下面哪种函数是回溯法中为避免无效搜索采取的策略（ B ）.
A、递归函数
B、剪枝函数
C、随机数函数
D、搜索函数
3、以下描述正确的是（B）
A、递归算法只能直接调用自身
B、递归函数是由函数自身给出定义的
C、每个递归函数不一定都要有非递归定义的初始值
D、以上都不正确
4、以下描述不正确的是（ C ）
A、组成算法的每条指令是没有歧义的
B、算法中每条指令的执行时间是有限的
C、在算法的循环结构中，指令的执行次数可以无限
D、组成算法的每条指令是清晰的
5、二分搜索算法是利用（ A ）实现的算法。

A、分治策略
B、动态规划法
C、贪心法
D、回溯法
6、下面关于算法的错误说法是( B )
A、算法必须有输出
B、算法必须在计算机上用某种语言实现
C、算法不一定有输入
D、算法必须在有限步执行后能结束
7、0-1背包问题的回溯算法所需的计算时间为（A）
A、O（n2n）
B、O（nlogn）
C、O（2n）
D、O（n）
8、有3个矩阵A维数是{10*100}，B维数是{100*5}，C维数是{5*50}，若按（（AB）C）
计算，3个矩阵连乘积需要的乘法次数是（ A ）
A、7500
B、75000
C、750
D、750000
9、用计算机解决问题的步骤一般为：（ D）
①编写程序②设计算法③分析问题④调试程序
A．①②③④ B. ③④①② C. ②③①④ D. ③②①④
10、以下哪种算法是以广度优先策略进行搜索的（B）
A、回溯法
B、分支界限法
C、贪心算法
D、随机化算法
11、设序列X={x1,x2,…,xm}和Y={y
1,y
2
,…,y
n
}的最长公共子序列为
Z={z1,z2,…,zk} ，则以下描述不正确的是（ D）
A、若xm=yn，则zk=xm=yn，且Z
k-1是X
m-1
和Y
n-1
的最长公共子序列
B、若xm≠yn且zk≠xm，则Z是x
m-1
和Y的最长公共子序列
C、若xm≠yn且zk≠yn，则Z是X和yn-1的最长公共子序列
D、若xm=yn，则zk≠xm≠yn，且Zk-1是Xm-1和Yn-1的最长公共子序列
12、下列算法中通常以深度优先方式系统搜索问题解的是（ D ）。

A、备忘录
B、动态规划法
C、贪心法
D、回溯法
13、Strassen矩阵乘法是利用（A）实现的算法。

A、分治策略
B、动态规划法
C、贪心法
D、回溯法
14、以下对于动态规划描述不正确的是（ D）
A、动态规划法与分治法类似，其基本思想也是将待求解问题分解成若干子问题
B、适合于用动态规划求解的问题，经分解得到的子问题往往不是互相独立的
C、具体的动态规划算法多种多样，但是他们具有相同的填表格式
D、动态规划求解问题时和分治法一样，对子问题重复计算多次
15、矩阵A是一个p*q矩阵，B是q*r矩阵，则其乘积C=AB是一个（ B）矩阵
A、p*q
B、p*r
C、q*r
D、p*q
16、将一个难以直接解决的大问题，分解成一些规模较小的相同问题，以便各个击破。

这属于（ B ）的解决方法。

A、动态规划
B、分治法
C、贪心算法
D、分支界限法
17、动态规划算法适用于解最优化问题，以下哪个不是动态规划法解决问题的步骤
（C）
A、找出最优解的性质，并刻画其结构特征
B、递归地定义最优值
C、以自顶向下的方式计算出最优值
D、根据计算最优值时得到的信息，构造最优解
18、在对问题的解空间树进行搜索的方法中，一个活结点有多次机会成为活结点的是
（ A）。

A、回溯法
B、分支限界法
C、回溯法和分支限界法
D、回溯法求解子集树问题
19、以下哪种算法是以深度优先策略进行搜索的（ A）
A、回溯法
B、分支界限法
C、贪心算法
D、随机化算法
20、（D）是贪心算法与动态规划算法的共同点。

A 、重叠子问题 B、构造最优解
C、贪心选择性质
D、最优子结构性质
21、下列算法中通常以自底向上的方式求解最优解的是（ B ）。

A、分治法
B、动态规划法
C、贪心法
D、回溯法
22、分支限界法解旅行售货员问题时，活结点表的组织形式是（ A ）。

A、优先队列
B、链表
C、栈
D、数组
23、回溯法搜索状态空间树是按照（C）的顺序。

A、中序遍历
B、广度优先遍历
C、深度优先遍历
D、层次优先遍历
23、衡量一个算法好坏的标准是（ C ）。

A、运行速度快
B、占用空间少
C、时间复杂度低
D、代码短
24、用搜索算法解旅行售货员问题时的解空间树是（B）。

A、子集树
B、排列树
C、深度优先生成树
D、广度优先生成树
25、以下增长最快的是（ D）
A、log
2n B、nlog
2
n C、n2 D、2n
26、背包问题的贪心算法所需的计算时间为（ B）。

A、O（n2n）
B、O（nlogn）
C、O（2n）
D、O（n）
27、备忘录方法是那种算法的变形。

（ B ）
A、分治法
B、动态规划法
C、贪心法
D、回溯法
15、一只青蛙一次可以跳上1级台阶，也可以跳上2级。

求该青蛙跳上一个n级的台阶总共有多少种跳法，并输出每种跳法具体怎么跳。

#include <iostream>
using namespace std;
void BackTrack_TAIJIE(int*x,int n,int i,int sum)
{ if(sum == n)
{
cout<<n<<"="<<x[0];
for(int k = 1; k < i; k++)
cout<<"+"<<x[k];
cout<<endl;
return ;
}
if(sum > n)
return ;
x[i] = 1;
BackTrack_TAIJIE(x,n,i+1,sum+1);
x[i] = 2;
BackTrack_TAIJIE(x,n,i+1,sum+2);
}
void ProcTaiJie(int n)
{
int* x = new int[n];
BackTrack_TAIJIE(x,n,0,0);
delete [] x;
}
int main()
{ cout<<" 跳法"<<endl;
ProcTaiJie(8);
return 0;
}
19. 高矮不同的12个人，排成两排，每排必须是从矮到高排列，而且第二排比对应的第一排的人高,问排列方式有多少种? 输出132种
#include<stdlib.h>
#include<stdio.h>
int arr[2][6];//2行6列数组，代表两个队列
int resolution = 0;//答案个数
int k0 = 0, k1 = 0;//各行已填充个数
/*
arr:数组
*/
void process(int curnum){
if(curnum == 12){
if(arr[1][5] == 0){
resolution++;
}
return ;
}
//如果0行填充个数与1行填充个数相等，则当前数填充0行
if(k0 == k1){
arr[0][k0] = curnum;
k0++;
process(curnum+1);
arr[0][k0] = 0;
k0--;
return;
}
//第0行最多填充到6个
if(k0 < 6){
arr[0][k0] = curnum;
k0++;
process(curnum+1);
arr[0][k0] = 0;
k0--;
}
arr[1][k1] = curnum;
k1++;
process(curnum+1);
arr[1][k1] = 0;
k1--;
}
int main(){
int* pr = &resolution;
//初始化数组
int i,j;
for(i = 0; i < 2; i++){
for(j = 0; j < 6; j++){
arr[i][j] = 0;
}
}
arr[0][0] = 1;
k0=1;
process(2);
arr[0][0] = 0;
printf("%d",resolution);
return 0;
}
24、把一个数组进行逆序存储，如1,2,3逆序存储为3,2,1 ，空间复杂度为O(1). （不太对）
#include <stdio.h>
int main()
{ int i, n, swap, array[10];
scanf("%d", &n);
for (i = 0; i < n; i++)
scanf("%d", &array[i]);
for (i = 0; i < n/2; i++)
{
swap = array[i];
array[i] = array[n-1-i];
array[n-1-i] = swap;
}
for (i = 0; i < n-1; i++)
printf("%d ", array[i]);
printf("%d\n", array[n-1]);
return 0;
}
4、最大子段和问题：给出一个数列，数列元素均为负整数、0、正整数。

请找出数列中的一个连续子数列，使得这个子数列中包含的所有元素之和最大，在和最大的前提下还要求该子数列包含的元素个数最多，并输出这个最大和以及该连续子数列在整个数列中的开始和结束两个位置。

要求时间复杂度为O（n）不太对
#include <iostream>
using namespace std;
void Print(int* a,int n,int* flag, int maxindex)
{
if(flag[maxindex] == 1)
cout<<a[maxindex]<<" ";
else
{
Print(a,n,flag,maxindex-1);
cout<<a[maxindex]<<" ";
}
}
int GetMaxSubSum(int* a,int n)
{
int dp[100];
int flag[100];
dp[0] = a[0];
for(int i = 1; i < n; i++)
{
if(dp[i-1] <= 0)
{
dp[i] = a[i];
flag[i] = 1;
}
else
{
dp[i] = a[i] + dp[i-1];
flag[i] = 2;
}
}
int max = INT_MIN;
int maxindex = 0;
for( i = 0; i < n; i++)
{
if(max < dp[i])
{
max = dp[i];
maxindex = i;
}
}
Print(a,n,flag,maxindex);
return max;
}
int main()
{
int a[] = {1 ,-1, 2, 2 ,3 ,-3, 4 ,-4};
cout<<GetMaxSubSum(a,sizeof(a)/4);
cout<<endl;
return 0;
}。