算法分析考试题

1. )(n T 给定数组a[0:n-1],试设计一个算法,在最坏情况下用n+[logn]-2次比较找出

a[0:n-1] 中的元素的最大值和次大值. (算法分析与设计习题 2.16 ) （分治法）

a 、 算法思想

用分治法求最大值和次大值首先将问题划分，即将划分成长度相等的两个序列，递归求出左边的最大值次大值，再求出右边的的最大值次大值，比较左右两边，最后得出问题的解。 b 、复杂度分析：

把问题划分为左右两种的情况，需要分别递归求解，时间复杂度可如下计算：

有递推公式为：

T(n)=1 n=1

T(n)= 2T(n/2)+1 n>1 所以，分治算法的时间复杂度是n+[logn]-2，当n 为奇数时，logn 取上线，当n 为偶数时，logn 取下线。//不知道为什么会-2！

C 、代码实现：

#include

int a[100];

void maxcmax(int i,int j,int &max,int &cmax)

{

int lmax,lcmax,rmax,rcmax;

int mid;

if (i==j)

{

max=a[i];

cmax=a[i];

}

else if (i==j-1)

if (a[i]

{

max=a[j];

cmax=a[i];

}

else

{

max=a[i];

cmax=a[j];

}

else

{

mid=(i+j)/2;

maxcmax(i,mid,lmax,lcmax);

maxcmax(mid+1,j,rmax,rcmax);

if(lmax>rmax)

if(lcmax>rmax)

{

max=lmax;

cmax=lcmax;

}

else

{

max=lmax;

cmax=rmax;

}

else

if(rcmax>lmax)

{

if(rmax==rcmax)

{

max=rmax;

cmax=lmax;

}

else

{

max=rmax;

cmax=rcmax;

}

}

else

{

max=rmax;

cmax=lmax;

}

}

}

int main()

{

int n;

int max,cmax;

printf("输入数组长度");

scanf("%d",&n);

printf("输入数组:\n");

for(int i=0;i

{scanf("%d",&a[i]);}

maxcmax(0,n-1,max,cmax);

printf("最大数为%d\n",max);

printf("次大数为%d\n",cmax);

return 0;

}

C、运行结果为

2.求数列的最大子段和(要求时间复杂为nlogn) (算法设计与分析吕国英清华大学出版社

135页4..3.3 二分法变异) （分治法）（也可用动态规划算法参看递归王晓东计算机算法设计与分析第三版p61页）

a、基本思想：

用分治法求最大子段和首先将问题划分，即将一直序列划分成长度相等的两个序列，

这时会出现3种情况，即①最大子段和在第一个序列，②最大子段和在第二个序列和③最大子段和在第一个序列与第二个序列之间。然后，将3种情况的最大子段和合并，取三者之中的最大值为问题的解。

b、复杂度分析：

对应划分得到的情况①和②，需要分别递归求解，对应情况③，两个并列的for循环的时间复杂度是O(n)，所以有递推公式为：

T(n)=1 n=1

T(n)= 2T(n/2)+n-1 n>1

所以，分治算法的时间复杂度是O(nlogn)

c、代码实现

#include

#define m 10

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

{

int sum=0;

if(left==right) sum=a[left]>0?a[left]:0;

else

{

int i=(left+right)/2;

int max1=MaxSubSum(a,left,i);

int max2=MaxSubSum(a,i+1,right);

int sum1=0,sum2=0;

for(int j=i;j>=left;j--)

{

sum1=sum1+a[j];

if(sum1>sum2)

sum2=sum1;

}

int sum3=0,sum4=0;

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

{

sum3=sum3+a[j];

if(sum3>sum4)

sum4=sum3;

}

sum=sum2+sum4;

if(sum

sum=max1;

if(sum

sum=max2;

return sum;

}

}

void main()

{

int a[m],d;

cout<<"请输入元素个数"<

cin>>d;

cout<<"请输入元素"<

for(int i=0;i

cin>>a[i];

cout<<"最大子段和为:"<

运行结果为：

3. 设X[0：n-1] 和 Y[0：n-1]为两个数组，每个数组中含有n 个已排好序的数。试设计一

个)(log n O 时间算法，找出X 和Y 的2n 个数的中位数。(分治法) a 、基本思想：

解决问题的核心：找出将大问题分割成较小规模的相同问题的切割点，并递归定义大问题与子问题之间的关系。

确定切割点：对于两个数组，我们可以从他们中分别选取出一个中位数，称为x,y ，并将两个数组的左右边界称之为aLeft,aRight,bLeft,bRight 。对比两个中位数，如果X 数组中的中位数大于Y 数组中的中位数，且X 数组中的元素个数为偶数个，则X 数组被切割为X[aLeft,x-1]，Y 被切割为Y[y,bRight]，如果X 数组的元素个数不为偶数个的话，则直接将X 切割为X[aLeft,x]。如果X 数组的中位数小于Y 数组的中位数，取值情况刚好相反。

递归关系：根据上面所述，对于原问题X[aLeft , aRight], Y[bLeft, bRight]。假设切割后的子问题为X[aLeft, x-1],Y[y,bRight]。则求解X[aLeft , aRight], Y[bLeft, bRight]问题的中位数，归结于求解子问题X[aLeft, x-1],Y[y,bRight]的中位数。

递归结束条件：当切割后得到的子问题的两个数组的长度都为1位时，整个递归结束。 b 、复杂度分析：

因为数组比较的范围每次缩小一半，所以有递推公式为：

T(n)=1 n=1

T(n)= T(n/2)+1 n>1

易算出时间复杂度为 )(log n O

c 、代码实现

#include

using namespace::std;

#define d 10

int median(int x[],int y[],int xLeft,int xRight,int yLeft,int yRight){

if(xLeft==xRight)

{

return (x[xLeft]+y[yLeft])/2;

}

int xm=(xLeft+xRight)/2;

int ym=(yLeft+yRight)/2;

if((xLeft+xRight)%2==0)

{//为奇数

if(x[xm]

{

median(x,y,xm,xRight,yLeft,ym);

}

else

{

median(x,y,xLeft,xm,ym,yRight);

}

}

else

{//为偶数

if(x[xm]

{

median(x,y,xm+1,xRight,yLeft,ym);

}

else

{

median(x,y,xLeft,xm,ym+1,yRight);

}

}

}

int main()

{

int m;int a[d],b[d];

cout<<"Enter dimension m:"<

cin>>m;

cout<<"Enter array a:"<

for(int i=0;i

cin>>a[i];

cout<<"Enter array b:"<

for(int j=0;j

cin>>b[j];

int mid=median(a,b,0,m-1,0,m-1);

cout<<"The median is:"<

return 0;

}

运行结果为：

4.设计一个O(n*n)时间的算法,找出由n个数组成的序列最长单调递增子序列. P87页(参考

P56页) （动态规划算法）

a、算法思路：

序列X按非递减顺序排列，形成新序列Y，问题就转变成求解X和Y的LCS。

b、时间复杂度：

使用快速排序，则排序过程的时间复杂度为O（nlgn），而求两个序列的LCS的时间复杂度为O（n^2）（因为X、Y长度相等），综合可知该解法的时间复杂度为O（n^2）。

c、代码实现

#include

#define m 10

//快速排序

void QuickSort(int R[],int s,int t)

{

int i=s,j=t;

int tmp;

if(s

{

tmp=R[s];

while(i!=j)

{

while(j>i&&R[j]>=tmp)

j--;

R[i]=R[j];

while(i

i++;

R[j]=R[i];

}

R[i]=tmp;

QuickSort(R,s,i-1);

QuickSort(R,i+1,t);

}

}

//找出最长公共子序列

void LCSLength(int x[],int y[],int n,int c[m][m],int b[m][m]) {

int i,j;

for(i=0;i

{

c[0][i]=0;

c[i][0]=0;

}

for(i=0;i

for(j=0;j

{

if(x[i]==y[j])

{

c[i][j]=c[i-1][j-1]+1;

b[i][j]=1;

}

else if(c[i-1][j]>=c[i][j-1])

{

c[i][j]=c[i-1][j];

b[i][j]=2;

}

else

{

c[i][j]=c[i][j-1];

b[i][j]=3;

}

}

}

void LCS(int i,int j,int *x,int b[m][m])

{

if(i<0||j<0)

return;

if(b[i][j]==1)

{

LCS(i-1,j-1,x,b);

cout<

}

else if(b[i][j]==2)

LCS(i-1,j,x,b);

else

LCS(i,j-1,x,b);

}

void main()

{

int x[m],y[m],d;

cout<<"请输入元素个数"<

cin>>d;

cout<<"请输入元素"<

for(int i=0;i

{

cin>>x[i];

y[i]=x[i];

}

int c[m][m]={0},b[m][m]={0};

QuickSort(x,0,d-1);

LCSLength(x,y,d,c,b);

cout<<"最长单调递增子序列为："<

LCS(d-1,d-1,x,b);

}

结果为：

7.礼物分配问题. 两兄弟Alan 和Bob, 共同分配n 个礼物. 每个礼物只能分给其中的一个人,且不能分成两个.每个礼物i 的价值为vi, 为正整数.设 a 和 b 分别表示Alan 和 Bob 所收到的礼物的总价值, V=b a V

n i i +=∑=1, 为所有礼物的总价值. 为使两兄弟高兴,我们希望尽

可能地均分这些礼物, 即 |a-b| 打到最小

试设计-O(n*V)时间的动态规划算法,使得|a-b| 达到最小, 并求出礼物的分割集合 （P77页）(动态规划算法)

8.（4.7）多处最优服务问题 P131页 (贪婪算法) (与十人打水的问题一样)

a 、算法思想：

贪心策略如下：首先对所有服务先按服务时间从小到大进行排序，然后按照排序结果，选出

最小的服务站点时间，依次安排服务。

b、时间复杂度：

程序主要是花费在对各顾客所需服务时间的排序和贪心算法，即计算平均服务时间上面。其中，贪心算法部分只有一重循环影响时间复杂度，其时间复杂度为O(n)：而排序算法的时间复杂度为O(nlogn)。因此，综合来看算法的时间复杂度为O(nlogn)。

c、代码实现：

#include

#include

#include

using namespace std;

using std::vector;

double greedy(vectorx,int s)

{

int minx;

vectorb(s+1,0);

int n=x.size();

sort(x.begin(),x.end());

int i,j,k;

for(i=0;i

{

minx=0x7fffffff;

k=0;

for(j=0;j

{

if(minx>b[j])

{

minx=b[j];

k=j;

}

}

b[k]+=x[i];

x[i]=b[k];

}

double t=0;

for(i=0;i

t/=n;

return t;

}

void main()

{

int n;//等待服务的顾客人数

int s;//服务点的个数

int i;

int a;

int t;//平均服务时间

vectorx;

cout<<"输入等待服务的人数:"<

cin>>n;

cout<<"输入服务站点数:"<

cin>>s;

cout<<"输入每个顾客需要等待的时间:"<

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

{

cin>>a;

x.push_back(a);

}

t=greedy(x, s);

cout<<"最少平均等待时间是:"<

}

运行结果为：

9. 键盘输入一个高精度的正整数N, 去掉其中任意S个数字后剩下的数字按左右次序将组成一个新的正整数.编程对给定的N和S,寻找一种方案使得剩下的数字组成的新数最小. (P133页贪婪算法)

10.最佳调度问题。假设有n个任务由k个并行的机器完成。完成任务i个需要的时间为i t。

试设计一个算法找出完成这n个任务的最佳调度，使得完成全部任务的时间最早。（回溯法）

11.用回溯法做第6题( 时间复杂度为n2,请详细分析时间复杂度)

12.八皇后问题选做

13．最多约数问题

问题描述:

正整数x的约数是能整除x的正整数。正整数x 的约数个数记为div(x)。例如，1，2，5，10 都是正整数10 的约数，且div(10)=4。设a 和b 是2 个正整数，a≤b，找出a和b之间约数个数最多的数x。

a、算法思想：数据规模到1000000000，较大，最一般做法会超时。可以利用n的因子数公式，如果n的素因子分解公式为：n = p1^r1 * p2^r2 * p3^r3 * …* pn^rn，那么n的因子数公式即为Div(n) = (r1+1)*(r2+1)*……*(rn+1)。所以，先打印素数表，用公式求即可。

b、时间复杂度分析

筛选法打印素数表的时间复杂度一定小于MAXsqr（MAX),求数m的因子个数的时间复杂度小于sqr（m）

c、代码实现

#include

#include

#include

#define MAX 100000

int prime[MAX];

bool a[MAX];

int cnt;

//筛选法打印素数表

void Initprime(){

int i, j;

cnt = 0;

for( i=2; i

if( a[i] == 0 ){

prime[cnt++] = i;

for( j=2*i; j

a[j] = 1;

}

}

}

//求数m的因子个数

int Div( int m ){

int tmp,ret=1;

if( m<100000 && a[m]==0 )

return 2;

for( int i=0; prime[i]*prime[i]<=m && i

tmp = 0;

while( m % prime[i] == 0 ){

tmp ++;

m /= prime[i];

}

ret = ret * ( tmp+1 );

}

}

if( m != 1 )

ret = ret * 2;

return ret;

}

int main( ){

int m, n;

int max, ret;

Initprime( );

while( scanf( "%d%d", &m, &n ) != EOF ){

max = 1;

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

ret = Div( i );

if( ret > max )

max = ret;

}

printf( "a和b之间约数个数最多的数为：%d\n", max );

}

return 0;

}

运行结果为