算法设计与分析的答案 第4章

合集下载

算法设计与分析知到章节答案智慧树2023年天津大学

算法设计与分析知到章节答案智慧树2023年天津大学

算法设计与分析知到章节测试答案智慧树2023年最新天津大学第一章测试1.下列关于效率的说法正确的是()。

参考答案:提高程序效率的根本途径在于选择良好的设计方法,数据结构与算法;效率主要指处理机时间和存储器容量两个方面;效率是一个性能要求,其目标应该在需求分析时给出2.算法的时间复杂度取决于()。

参考答案:问题的规模;待处理数据的初态3.计算机算法指的是()。

参考答案:解决问题的有限运算序列4.归并排序法的时间复杂度和空间复杂度分别是()。

参考答案:O(nlog2n);O(n)5.将长度分别为m,n的两个单链表合并为一个单链表的时间复杂度为O(m+n)。

()参考答案:错6.用渐进表示法分析算法复杂度的增长趋势。

()参考答案:对7.算法分析的两个主要方面是时间复杂度和空间复杂度的分析。

()参考答案:对8.某算法所需时间由以下方程表示,求出该算法时间复杂度()。

参考答案:O(nlog2n)9.下列代码的时间复杂度是()。

参考答案:O(log2N)10.下列算法为在数组A[0,...,n-1]中找出最大值和最小值的元素,其平均比较次数为()。

参考答案:3n/2-3/2第二章测试1.可用Master方法求解的递归方程的形式为()。

参考答案:T(n)=aT(n/b)+f(n) , a≥1, b>1, 为整数, f(n)>0.2.参考答案:对3.假定,, 递归方程的解是. ( )参考答案:对4.假设数组A包含n个不同的元素,需要从数组A中找出n/2个元素,要求所找的n/2个元素的中点元素也是数组A的中点元素。

针对该问题的任何算法需要的时间复杂度的下限必为。

( )参考答案:错5.使用Master方法求解递归方程的解为().参考答案:6.考虑包含n个二维坐标点的集合S,其中n为偶数,且所有坐标点中的均不相同。

一条竖直的直线若能把S集合分成左右两部分坐标点个数相同的子集合,则称直线L为集合S的一条分界线。

若给定集合S,则可在时间内找到这条分界线L。

习题答案第四章-算法设计与分析-吕国英

习题答案第四章-算法设计与分析-吕国英

习题答案第四章-算法设计与分析-吕国英printf("n=?,d=?,a1=?,a2=?");scanf("%d%d%d%d\n",&n,&d,&a1,&a2); printf("%d\n",fun(n));return 0;}int fun(int n){if(n==1)return a1;if(n==2)return a2;return fun(n-2)-(fun(n-1)-d)*2;}5.#include<stdio.h>char chess[8][8];int is_safe(int row,int col);int queen(int row,int col,int n); int main(void){int i,j;for(i=0;i<8;i++)for(j=0;j<8;j++)chess[i][j]='X';queen(0,0,0);for(i=0;i<8;i++){for(j=0;j<8;j++)printf("%c ",chess[i][j]);printf("\n");}return 0;}int is_safe(int row,int col){int i,j;for(i=0;i<8;i++){if(chess[row][i]=='Q')return 0;if(chess[i][col]=='Q')return 0;}i=row;j=col;while(i!=-1&&j!=-1){if(chess[i--][j--]=='Q')return 0;}i=row;j=col;while(i!=-1&&j!=8){if(chess[i--][j++]=='Q')return 0;}i=row;j=col;while(i!=8&&j!=-1){if(chess[i++][j--]=='Q')return 0;}i=row;j=col;while(i!=8&&j!=8){if(chess[i++][j++]=='Q')return 0;}return 1;}int queen(int row,int col,int n) {int i,j;int result=0;if(n==8)return 1;elseif(is_safe(row,col)){chess[row][col]='Q';for(i=0;i<8;i++)for(j=0;j<8;j++){result+=queen(i,j,n+1);if(result>0)break;}if(result>0)return 1;else{chess[row][col]='X';return 0;}}elsereturn 0;}6.#include<stdio.h>int main(void){int i,j,k;for(i=1;i<=33;i++)for(j=1;j<=50;j++){k=100-i-j;if(k%2==0){if(3*i+2*j+k/2==100)printf("大马%d\n中马%d\n小马%d\n\n\n",i,j,k); }}return 0;}7.#include<stdio.h>int main(void){int i;for(i=1;i<=10000;i++){if(i%2==1&&i%3==2&&i%5==4&&i%6==5&&i%7==0) printf("%d\n",i);}return 0;}8.#include<stdio.h>int main(void){int i;int sum;int a1,a2,a3,a4;for(i=1000;i<=9999;i++){a1=i%10;a2=i/10%10;if(a1!=a2){a3=i/100%10;if(a1!=a3&&a2!=a3){a4=i/1000;if(a1!=a4&&a2!=a4&&a3!=a4){sum=(a1+a2+a3+a4)*(a1+a2+a3+a4);if(i%sum==0)printf("%d\n",i);}}}}return 0;}9.#include<stdio.h>#define N 10void max_min(int *a,int m,int n,int *min1,int *min2,int *max1,int *max2); int main(void){int a[N]={2,3,4,5,34,7,9,6,43,21};int min1,min2;int max1,max2;max_min(a,0,N-1,&min1,&min2,&max1,&max2);printf("min1=%d\nmin2=%d\nmax1=%d\nmax2=%d\n",min1,min2,max1,max2);return 0;}void max_min(int *a,int m,int n,int *min1,int *min2,int *max1,int *max2) {int lmin1,lmin2,lmax1,lmax2;int rmin1,rmin2,rmax1,rmax2;int mid;if(m==n){*min1=*min2=*max1=*max2=a[m];}elseif(m==n-1){if(a[m]<a[n]){*min1=a[m];*min2=a[n];*max1=a[n];*max2=a[m];}else{*min1=a[n];*min2=a[m];*max1=a[m];*max2=a[n];}}else{mid=(m+n)/2;max_min(a,m,mid,&lmin1,&lmin2,&lmax1,&lmax2); max_min(a,mid+1,n,&rmin1,&rmin2,&rmax1,&rmax2); if(lmin1<rmin1){if(lmin2<rmin1){*min1=lmin1;*min2=lmin2;}else{*min1=lmin1;*min2=rmin1;}}elseif(rmin2<lmin1){*min1=rmin1;*min2=rmin2;}else{*min1=rmin1;*min2=lmin1;}if(lmax1>rmax1){if(lmax2>rmax1){*max1=lmax1;*max2=lmax2;}else{*max1=lmax1;*max2=rmax1;}}elseif(rmax2>lmax1){*max1=rmax1;*max2=rmax2;}else{*max1=rmax1;*max2=lmax1;}}}10.#include<stdio.h>int add(int *a,int flag,int right); int main(void){int a[10]={1,2,3,4,5,6,7,8,9,10}; int sum=add(a,0,9);printf("%d\n",sum);return 0;int add(int *a,int flag,int right){int mid;if(flag==right){return a[flag];}elseif(flag==right-1){return a[flag]+a[right];}else{mid=(flag+right)/2;return add(a,flag,mid)+add(a,mid+1,right); }}11.#include<stdio.h>int main(void){int a[5][3]={{-50,17,-42},{-47,-19,-3},{36,-34,-43},{-30,-43,34},{-23,-8,-45}};int i,j;int max,n;int sum=0;for(i=0;i<5;i++){max=a[i][0];n=0;for(j=1;j<3;j++){if(a[i][j]>max){max=a[i][j];n=j;}sum+=max;printf("a[%d][%d]=%d\n",i,n,max);}printf("%d\n",sum);return 0;}12./** File: newmain.c* Author: nirnava** Created on 2010年4月22日, 下午5:21*/#include<stdio.h>#include<stdlib.h>#define N 4void matrix_mul(int *mul1,int *mul2,int *mul3,int length); void matrix_add_sub(int * A,int * B,int * C,int m,char ch); void update_half_value(int * A,int * B,int m);void get_half_value(int * A,int * B,int m);int main(void){int i,j;int mul1[N*N]={1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6};int mul2[N*N]={7,8,9,10,1,2,3,4,5,6,7,8,9,10,1,2};int mul3[N*N];matrix_mul(mul1,mul2,mul3,N);for(i=0;i<N*N;i++){printf("%5d",mul3[i]);if((i+1)%N==0)printf("\n");}return 0;}void matrix_add_sub(int * A,int * B,int * C,int m,char ch) {int i;for(i=0;i<m*m;i++){if(ch=='+')C[i]=A[i]+B[i];C[i]=A[i]-B[i];}}void update_half_value(int * A,int * B,int m) {int i,j;for(i=0;i<m/2;i++){for(j=0;j<m/2;j++){B[i*m+j]=A[i*m/2+j];}}}void get_half_value(int * A,int * B,int m) {int i,j;for(i=0;i<m/2;i++){for(j=0;j<m/2;j++){A[i*m/2+j]=B[i*m+j];}}}void matrix_mul(int *A,int *B,int *C,int m) {if(m==2){int D,E,F,G,H,I,J;D=A[0]*(B[1]-B[3]);E=A[3]*(B[2]-B[0]);F=(A[2]+A[3])*B[0];G=(A[0]+A[1])*B[3];H=(A[2]-A[0])*(B[0]+B[1]);I=(A[1]-A[3])*(B[2]+B[3]);J=(A[0]+A[3])*(B[0]+B[3]);C[0]=E+I+J-G;C[1]=D+G;C[2]=E+F;C[3]=D+H+J-F;return ;}{int A1[m*m/4],A2[m*m/4],A3[m*m/4],A4[m*m/4];int B1[m*m/4],B2[m*m/4],B3[m*m/4],B4[m*m/4];int C1[m*m/4],C2[m*m/4],C3[m*m/4],C4[m*m/4];int D[m*m/4],E[m*m/4],F[m*m/4],G[m*m/4],H[m*m/4],I[m*m/4],J[m*m/4]; int temp1[m*m/4],temp2[m*m/4];get_half_value(A1,&A[0],m);get_half_value(A2,&A[m/2],m);get_half_value(A3,&A[m*m/2],m);get_half_value(A4,&A[m*m/2+m/2],m);get_half_value(B1,&B[0],m);get_half_value(B2,&B[m/2],m);get_half_value(B3,&B[m*m/2],m);get_half_value(B4,&B[m*m/2+m/2],m);matrix_add_sub(B2,B4,temp1,m/2,'-');matrix_mul(A1,temp1,D,m/2);matrix_add_sub(B3,B1,temp1,m/2,'-');matrix_mul(A4,temp1,E,m/2);matrix_add_sub(A3,A4,temp1,m/2,'+');matrix_mul(temp1,B1,F,m/2);matrix_add_sub(A1,A2,temp1,m/2,'+');matrix_mul(temp1,B4,G,m/2);matrix_add_sub(A3,A1,temp1,m/2,'-');matrix_add_sub(B1,B2,temp2,m/2,'+');matrix_mul(temp1,temp2,H,m/2);matrix_add_sub(A2,A4,temp1,m/2,'-');matrix_add_sub(B3,B4,temp2,m/2,'+');matrix_mul(temp1,temp2,I,m/2);matrix_add_sub(A1,A4,temp1,m/2,'+');matrix_add_sub(B1,B4,temp2,m/2,'+');matrix_mul(temp1,temp2,J,m/2);matrix_add_sub(E,I,temp1,m/2,'+');matrix_add_sub(J,G,temp2,m/2,'-');matrix_add_sub(temp1,temp2,C1,m/2,'+');matrix_add_sub(D,G,C2,m/2,'+');matrix_add_sub(E,F,C3,m/2,'+');matrix_add_sub(D,H,temp1,m/2,'+');matrix_add_sub(J,F,temp2,m/2,'-');matrix_add_sub(temp1,temp2,C4,m/2,'+');update_half_value(C1,&C[0],m);update_half_value(C2,&C[m/2],m);update_half_value(C3,&C[m*m/2],m);update_half_value(C4,&C[m*m/2+m/2],m);return ;}}13.#include<stdio.h>int main(void){int a[6][7]={{16,4,3,12,6,0,3},{4,-5,6,7,0,0,2},{6,0,-1,-2,3,6,8},{5,3,4,0,0,-2,7},{-1,7,4,0,7,-5,6},{0,-1,3,4,12,4,2}};int b[6][7],c[6][7];int i,j,k;int max;int flag;int temp;for(i=0;i<6;i++)for(j=0;j<7;j++){b[i][j]=a[i][j];c[i][j]=-1;}for(i=1;i<5;i++){for(j=0;j<7;j++){max=0;for(k=j-2;k<=j+2;k++) {if(k<0)continue;elseif(k>6)break;else{if(b[i][j]+b[i-1][k]>max) {max=b[i][j]+b[i-1][k]; flag=k;}}}b[i][j]=max;c[i][j]=flag;}}for(j=1;j<=5;j++){max=0;for(k=j-2;k<=j+2;k++) {if(k<0)continue;elseif(k>6)break;else{if(b[i][j]+b[i-1][k]>max) {max=b[i][j]+b[i-1][k]; flag=k;}}}b[i][j]=max;c[i][j]=flag;}max=0;for(j=1;j<=5;j++){if(b[i][j]>max){max=b[i][j];flag=j;}}printf("%d\n",max);temp=c[i][flag];printf("%5d",a[i][temp]); for(j=i;j>0;j--){temp=c[j][temp];printf("%5d",a[j-1][temp]); }printf("\n");return 0;}14.#include<stdio.h>int main(void){int A[6]={0,3,7,9,12,13}; int B[6]={0,5,10,11,11,11}; int C[6]={0,4,6,11,12,12}; int AB[6][6];int temp[6];int abc[6];int max;int flag;int i,j,k;for(i=0;i<=5;i++){max=0;for(j=0;j<=i;j++){AB[i][j]=A[i-j]+B[j];if(AB[i][j]>max)max=AB[i][j];}temp[i]=max;}max=0;for(i=0;i<=5;i++){abc[i]=temp[i]+C[5-i];if(abc[i]>max){max=abc[i];flag=i;}}printf("max=%d\n",max); printf("c=%d\n",5-flag); max=max-C[5-flag];for(i=0;i<=flag;i++){if(AB[flag][i]==max){printf("b=%d\n",i);printf("a=%d\n",flag-i);break;}}return 0;}16.#include<stdio.h>#define N 100int search(int *a,int left,int right); int sum_buf(int *a,int left,int right); int main(void){int a[N];int i;int s;for(i=0;i<N;i++)a[i]=1;a[24]=2;s=search(a,0,N-1);printf("%d\n",s);return 0;}int sum_buf(int *a,int left,int right) {int i;int sum=0;for(i=left;i<=right;i++)sum+=a[i];return sum;}int search(int *a,int left,int right) {int mid=(left+right)/2;if(left==right-1){if(a[left]<a[right])return right;elsereturn left;}if(mid*2!=(right+left-1)){if(sum_buf(a,left,mid-1)>sum_buf(a,mid+1,right)) {return search(a,left,mid-1);}elseif(sum_buf(a,left,mid-1)<sum_buf(a,mid+1,right)) {return search(a,mid+1,right);}elsereturn mid;}else{if(sum_buf(a,left,mid)>sum_buf(a,mid+1,right)) return search(a,left,mid);elsereturn search(a,mid+1,right);}}17.#include<stdio.h>int job[6][2]={{3,8},{12,10},{5,9},{2,6},{9.3},{11,1}};int x[6],bestx[6],f1=0,bestf,f2[7]={0};void try(int i);void swap(int a,int b);int main(void){int i,j;bestf=32767;for(i=0;i<6;i++)x[i]=i;try(0);for(i=0;i<6;i++)printf("%d ",bestx[i]);printf("\nbestf=%d\n",bestf); return 0;}void try(int i){int j;if(i==6){for(j=0;j<6;j++)bestx[j]=x[j];bestf=f2[i];}else{for(j=i;j<6;j++){f1=f1+job[x[j]][0];if(f2[i]>f1)f2[i+1]=f2[i]+job[x[j]][1]; elsef2[i+1]=f1+job[x[j]][1];if(f2[i+1]<bestf){swap(i,j);try(i+1);swap(i,j);}f1=f1-job[x[j]][0];}}}void swap(int i,int j){int temp;temp=x[i];x[i]=x[j];x[j]=temp;}18.#include<stdio.h>#define N 5 //N个数字#define M 2 //M个加号char buf[N];int a[N];char b[M+1][N];int c[M+1];int try(int t);void swap(int t1,int t2); int add();void output();int min=99999;int main(){int i;for(i=0;i<N;i++){scanf("%c",&buf[i]);}a[0]=0;for(i=1;i<=M;i++){a[i]=1;}for(;i<N;i++){a[i]=0;}try(1);output();printf("%d\n",min);return 0;}int try(int t){int j;int i;int sum;if(t>=N){sum=add();if(sum<min){min=sum;for(i=0;i<M+1;i++){c[i]=atoi(b[i]);}}/*for(i=0;i<N;i++){printf("%d",a[i]);}printf("\n");*/}else{for(j=t;j<N;j++){//if(a[t]!=a[j]){swap(t,j);try(t+1);swap(t,j);}//else//try(t+1);}}}void swap(int t1,int t2) {int t;t=a[t1];a[t1]=a[t2];a[t2]=t;}int add(){int sum=0;int i=0;int j;int k=0;int h=0;for(i=0;i<M+1;i++)for(j=0;j<N;j++)b[i][j]='Q';i=0;j=0;h=0;k=0;for(j=0;j<N;j++){if(a[j]==1){h=0;i++;b[i][h]=buf[j];//printf("%d ",atoi(b[i]));//printf("%d %d %c \n",i,h,b[i][h]); h++;}else{b[i][h]=buf[j];//printf("%d %d %c \n",i,h,b[i][h]); //printf("%d ",atoi(b[i]));h++;}}/*for(i=0;i<M+1;i++){for(j=0;j<N;j++)printf("%c ",b[i][j]);printf("\n");}*/for(i=0;i<M+1;i++){sum+=atoi(b[i]);}return sum;}void output(){int i;for(i=0;i<M+1;i++){printf("%d",atoi(b[i]));if(i!=M)printf("+");}printf("=");}19.#include<stdio.h>int main(void){int buf[100];int m,n;int i,j;buf[0]=1;buf[1]=1;scanf("%d%d",&n,&m);for(i=1;i<n;i++){buf[i+1]=buf[i];for(j=i;j>0;j--){buf[j]=buf[j]+buf[j-1];}}printf("%d\n",buf[m]);return 0;}20.#include<stdio.h>int max_sum4(int *a,int n);int max_sub_sum(int *a,int left,int right);int main(void){int a[6]={-2,11,-4,13,-5,-2};printf("%d\n",max_sum4(a,5));return 0;}int max_sum4(int *a,int n){return max_sub_sum(a,0,n);}int max_sub_sum(int *a,int left,int right){int center,i,max,left_sum,right_sum,s1,s2,s3,s4,lefts,rights,leftl,rightl; int buf[4];if(left==right)return a[left];else{center=(left+right)/2;left_sum=max_sub_sum(a,left,center); right_sum=max_sub_sum(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(i=center+1;i<=right;i++){rights+=a[i];if(rights>s2)s2=rights;}s3=0;leftl=0;for(i=left;i<=center;i++){leftl+=a[i];if(leftl>s3)s3=leftl;}s4=0;rightl=0;for(i=right;i>=center+1;i--){rightl+=a[i];if(rightl>s4)s4=rightl;}buf[0]=s1+s2;buf[1]=s4+s3;buf[2]=left_sum;buf[3]=right_sum;max=0;for(i=0;i<=3;i++){if(buf[i]>max)max=buf[i];}return max; }}。

算法设计与分析基础课后习题答案solu4

算法设计与分析基础课后习题答案solu4
Solving it by backward substitutions for n = 2k yields the following:
C(2k) = 2C(2k−1) + 1 = 2[2C(2k−2) + 1] + 1 = 22C(2k−2) + 2 + 1 = 22[2C(2k−3) + 1] + 2 + 1 = 23C(2k−3) + 22 + 2 + 1 = ... = 2iC(2k−i) + 2i−1 + 2i−2 + ... + 1 = ... = 2kC(2k−k) + 2k−1 + 2k−2 + ... + 1 = 2k − 1 = n − 1.
Design a divide-and-conquer algorithm for this problem.
2
Hints to Exercises 4.1
1. In more than one respect, this question is similar to the divide-and-conquer computation of the sum of n numbers. Also, you were asked to analyze an almost identical algorithm in Exercises 2.4.
b. Set up and solve a recurrence relation for the number of multiplications made by this algorithm.
c. How does this algorithm compare with the brute-force algorithm for this problem?

算法分析与设计(山东联盟)智慧树知到答案章节测试2023年泰山学院

算法分析与设计(山东联盟)智慧树知到答案章节测试2023年泰山学院

绪论单元测试1.山东师范大学的管教授在哪个问题上给出了比较好的解决方法。

A:邮递员问题B:背包问题C:装载问题D:最大团问题答案:A第一章测试1.算法具备的四个基本性质是()A:输入B:有限性C:确定性D:输出答案:ABCD2.算法就是程序A:错B:对答案:A3.描述渐进上界的符号是()A:ΩB:ωC:OD:θ答案:C4.f(n)=3n2+n+1,下面不正确的是()A:f(n)=O(n3)B:f(n)=O(n2)C:f(n)=O(2n)D:f(n)=O(3n2)答案:C5.在算法分析中,我们希望找到更加高阶的上界函数A:错B:对答案:A第二章测试1.Strassen 矩阵乘法是利用()实现的算法。

A:贪心法B:分治策略C:动态规划法D:回溯法答案:B2.使用分治法求解不需要满足的条件是()A:子问题不能够重复B:子问题的解可以合并C:子问题必须是一样的D:原问题和子问题使用相同的方法解答案:C3.实现棋盘覆盖算法利用的算法是()。

A:分治法B:回溯法C:动态规划法D:贪心法答案:A4.实现循环赛日程表利用的算法是()。

A:贪心法B:回溯法C:分治策略D:动态规划法答案:C5.从分治法的一般设计模式可以看出,用它设计出的程序一般是递归算法A:对B:错答案:A第三章测试1.动态规划算法一般分成()三个阶段。

A:求解B:分析C:分段D:汇总答案:ABC2.动态规划的基本要素有()?A:备忘录方法B:最优子结构C:子问题的重叠性质答案:ABC3.用动态规划法求解的问题都可以分解为相互重叠的子问题。

A:对B:错答案:A4.动态规划法利用递推关系式()计算,实现动态规划过程。

A:循环B:递归C:自底向上D:自顶向下答案:C5.最优子结构是问题可以用动态规划法求解的前提。

A:错B:对答案:B第四章测试1.贪心算法中每次做出的贪心选择都是全局最优选择。

A:对B:错答案:B2.下面问题不能使用贪心法解决的是A:N皇后问题B:最小花费生成树问题C:背包问题D:单源最短路径问题答案:A3.背包问题的贪心算法所需的计算时间为A:O(n2n)B:O(n)C:O(nlogn)D:O(2n)答案:C4.哈夫曼编码是自底向上构造的A:错B:对答案:B5.Kruskal算法的时间复杂度是A:O(eloge)B:O(n)C:O(nlogn)D:O(2n)答案:A第五章测试1.回溯法就是穷举法A:错B:对答案:A2.回溯法使用的是广度优先遍历A:对B:错答案:B3.回溯法必须寻找一个限界函数A:对B:错答案:B4.使用回溯法时可以考虑以下哪些方面()A:约束函数B:解空间结构C:解的向量形式D:解的最优子结构性质答案:ABC5.回溯法在处理n皇后问题时,必须把解空间组织成子集树。

算法分析与设计教程习题解答_秦明

算法分析与设计教程习题解答_秦明

算法分析与设计教程习题解答第1章 算法引论1. 解:算法是一组有穷的规则,它规定了解决某一特定类型问题的一系列计算方法。

频率计数是指计算机执行程序中的某一条语句的执行次数。

多项式时间算法是指可用多项式函数对某算法进行计算时间限界的算法。

指数时间算法是指某算法的计算时间只能使用指数函数限界的算法。

2. 解:算法分析的目的是使算法设计者知道为完成一项任务所设计的算法的优劣,进而促使人们想方设法地设计出一些效率更高效的算法,以便达到少花钱、多办事、办好事的经济效果。

3. 解:事前分析是指求出某个算法的一个时间限界函数(它是一些有关参数的函数);事后测试指收集计算机对于某个算法的执行时间和占用空间的统计资料。

4. 解:评价一个算法应从事前分析和事后测试这两个阶段进行,事前分析主要应从时间复杂度和空间复杂度这两个维度进行分析;事后测试主要应对所评价的算法作时空性能分布图。

5. 解:①n=11; ②n=12; ③n=982; ④n=39。

第2章 递归算法与分治算法1. 解:递归算法是将归纳法的思想应用于算法设计之中,递归算法充分地利用了计算机系统内部机能,自动实现调用过程中对于相关且必要的信息的保存与恢复;分治算法是把一个问题划分为一个或多个子问题,每个子问题与原问题具有完全相同的解决思路,进而可以按照递归的思路进行求解。

2. 解:通过分治算法的一般设计步骤进行说明。

3. 解:int fibonacci(int n) {if(n<=1) return 1;return fibonacci(n-1)+fibonacci(n-2); }4. 解:void hanoi(int n,int a,int b,int c) {if(n>0) {hanoi(n-1,a,c,b); move(a,b);hanoi(n-1,c,b,a); } } 5. 解:①22*2)(--=n n f n② )log *()(n n n f O =6. 解:算法略。

算法设计与分析智慧树知到答案章节测试2023年山东交通学院

算法设计与分析智慧树知到答案章节测试2023年山东交通学院

第一章测试1.解决一个问题通常有多种方法。

若说一个算法“有效”是指( )A:这个算法能在人的反应时间内将问题解决B:(这个算法能在一定的时间和空间资源限制内将问题解决)和(这个算法比其他已知算法都更快地将问题解决)C:这个算法能在一定的时间和空间资源限制内将问题解决D:这个算法比其他已知算法都更快地将问题解决答案:B2.农夫带着狼、羊、白菜从河的左岸到河的右岸,农夫每次只能带一样东西过河,而且,没有农夫看管,狼会吃羊,羊会吃白菜。

请问农夫能不能过去?()A:不一定B:不能过去C:能过去答案:C3.下述()不是是算法的描述方式。

A:自然语言B:程序设计语言C:E-R图D:伪代码答案:C4.有一个国家只有6元和7元两种纸币,如果你是央行行长,你会设置()为自动取款机的取款最低限额。

A:40B:42C:29D:30答案:D5.算法是一系列解决问题的明确指令。

()A:对B:错答案:A6.程序=数据结构+算法()A:错B:对答案:B7.同一个问题可以用不同的算法解决,同一个算法也可以解决不同的问题。

()A:错答案:B8.算法中的每一条指令不需有确切的含义,对于相同的输入不一定得到相同的输出。

( )A:错B:对答案:A9.可以用同样的方法证明算法的正确性与错误性 ( )A:对B:错答案:B10.求解2个数的最大公约数至少有3种方法。

( )A:错B:对答案:A11.没有好的算法,就编不出好的程序。

()A:对B:错答案:A12.算法与程序没有关系。

( )A:错B:对答案:A13.我将来不进行软件开发,所以学习算法没什么用。

( )A:对B:错答案:B14.gcd(m,n)=gcd(n,m m od n)并不是对每一对正整数(m,n)都成立。

( )A:错B:对答案:A15.既然程序设计语言可以描述算法,所以算法就是程序。

( )A:错B:对答案:A第二章测试1.并不是所有的算法,规模更大的输入需要更长的运行时间。

( )A:对答案:B2.算法效率分析框架主要关心一个算法的基本操作次数的增长次数,并把它作为算法效率的主要指标。

算法设计与分析第三版第四章课后习题答案

算法设计与分析第三版第四章课后习题答案

算法设计与分析第三版第四章课后习题答案4.1 线性时间选择问题习题4.1问题描述:给定一个长度为n的无序数组A和一个整数k,设计一个算法,找出数组A中第k小的元素。

算法思路:本题可以使用快速选择算法来解决。

快速选择算法是基于快速排序算法的思想,通过递归地划分数组来找到第k小的元素。

具体步骤如下: 1. 选择数组A的一个随机元素x作为枢纽元。

2. 使用x将数组划分为两个子数组A1和A2,其中A1中的元素小于等于x,A2中的元素大于x。

3. 如果k等于A1的长度,那么x就是第k小的元素,返回x。

4. 如果k小于A1的长度,那么第k小的元素在A1中,递归地在A1中寻找第k小的元素。

5. 如果k大于A1的长度,那么第k小的元素在A2中,递归地在A2中寻找第k-A1的长度小的元素。

6. 递归地重复上述步骤,直到找到第k小的元素。

算法实现:public class LinearTimeSelection {public static int select(int[] A, int k) { return selectHelper(A, 0, A.length - 1, k);}private static int selectHelper(int[] A, int left, int right, int k) {if (left == right) {return A[left];}int pivotIndex = partition(A, left, righ t);int length = pivotIndex - left + 1;if (k == length) {return A[pivotIndex];} else if (k < length) {return selectHelper(A, left, pivotInd ex - 1, k);} else {return selectHelper(A, pivotIndex + 1, right, k - length);}}private static int partition(int[] A, int lef t, int right) {int pivotIndex = left + (right - left) / 2;int pivotValue = A[pivotIndex];int i = left;int j = right;while (i <= j) {while (A[i] < pivotValue) {i++;}while (A[j] > pivotValue) {j--;}if (i <= j) {swap(A, i, j);i++;j--;}}return i - 1;}private static void swap(int[] A, int i, int j) {int temp = A[i];A[i] = A[j];A[j] = temp;}}算法分析:快速选择算法的平均复杂度为O(n),最坏情况下的复杂度为O(n^2)。

大学_计算机算法设计与分析第4版(王晓东著)课后答案下载

大学_计算机算法设计与分析第4版(王晓东著)课后答案下载

计算机算法设计与分析第4版(王晓东著)课后答
案下载
计算机算法设计与分析第4版内容简介
第1章算法概述
1.1 算法与程序
1.2 算法复杂性分析
1.3 NP完全性理论
算法分析题1
算法实现题1
第2章递归与分治策略
2.1 递归的概念
2.2 分治法的基本思想
2.3 二分搜索技术
2.4 大整数的乘法
2.5 Strassen矩阵乘法
2.6 棋盘覆盖
2.7 合并排序
2.8 快速排序
2.9 线性时间选择
2.10 最接近点对问题
第3章动态规划
第4章贪心算法
第5章回溯法
第6章分支限界法
第7章随机化算法
第8章线性规划与网络流
附录A C++概要
参考文献
计算机算法设计与分析第4版目录
本书是普通高等教育“十一五”__规划教材和国家精品课程教材。

全书以算法设计策略为知识单元,系统介绍计算机算法的设计方法与分析技巧。

主要内容包括:算法概述、递归与分治策略、动态规划、贪心算法、回溯法、分支限界法、__化算法、线性规划与网络流等。

书中既涉及经典与实用算法及实例分析,又包括算法热点领域追踪。

为突出教材的`可读性和可用性,章首增加了学习要点提示,章末配有难易适度的算法分析题和算法实现题;配套出版了《计算机算法设计与分析习题解答(第2版)》;并免费提供电子课件和教学服务。

算法设计与分析第04章 贪心算法PPT课件

算法设计与分析第04章 贪心算法PPT课件
9
4.1 活动安排问题
若被检查的活动i的开始时间Si小于最近选择的活动j 的结束时间fi,则不选择活动i,否则选择活动i加入集 合A中。
贪心算法并不总能求得问题的整体最优解。但对 于活动安排问题,贪心算法greedySelector却总能求 得的整体最优解,即它最终所确定的相容活动集合A的 规模最大。这个结论可以用数学归纳法证明。
•}
6
4.1 活动安排问题
由于输入的活动以其完成时间的非减序排列,所 以算法greedySelector每次总是选择具有最早完成 时间的相容活动加入集合A中。直观上,按这种方法 选择相容活动为未安排活动留下尽可能多的时间。也 就是说,该算法的贪心选择的意义是使剩余的可安排 时间段极大化,以便安排尽可能多的相容活动。
算法greedySelector的效率极高。当输入的活 动已按结束时间的非减序排列,算法只需O(n)的时间 安排n个活动,使最多的活动能相容地使用公共资源。 如果所给出的活动未按非减序排列,可以用O(nlogn) 的时间重排。
7
4.1 活动安排问题
例:设待安排的11个活动的开始时间和结束时间按结 束时间的非减序排列如下:
13
4.2 贪心算法的基本要素
3.贪心算法与动态规划算法的差异
贪心算法和动态规划算法都要求问题具有最优子结构 性质,这是2类算法的一个共同点。但是,对于具有最 优子结构的问题应该选用贪心算法还是动态规划算法 求解?是否能用动态规划算法求解的问题也能用贪心算 法求解?下面研究2个经典的组合优化问题,并以此说 明贪心算法与动态规划算法的主要差别。
11
4.2 贪心算法的基本要素
1.贪心选择性质
所谓贪心选择性质是指所求问题的整体最优解可以通 过一系列局部最优的选择,即贪心选择来达到。这是 贪心算法可行的第一个基本要素,也是贪心算法与动 态规划算法的主要区别。

《计算机算法-设计与分析导论》课后习题答案

《计算机算法-设计与分析导论》课后习题答案

它的工作流程如下:首先在未排序序列(初始时为整个序列)中选择其中最大的元素max ,然后将该元素同未排序序列中的最后一个元素交换。

这时,max 元素就包含在由每次的最大元素组成的已排序序列之中了,也就说这时的max 已经不在未排序序列之中了。

重复上述过程直到完成整个序(a) 写出Maxsort 算法。

其中待排序序列为E ,含有n 个元素,脚标为范围为0,,1n-。

void Maxsort(Element[] E) {int maxID = 0;for (int i=E.length; i>1; i--) {for (int j=0; j<i; j++) {if (E[j] > E[maxID]) maxID = k;}E[i] <--> E[maxID];}}最坏情况同平均情况是相同的都是11(1)()2n i n n C n i -=-==∑。

该算法通过连续几遍浏览序列实现。

排序策略是顺序比较相邻元素,如果这两个元素未排序则交换这两个元素的位置。

也就说,首先比较第一个元素和第二个元素,如果第一个元素大于第二个元素,这交换这两个元素的位置;然后比较第二个元素与第三个元素,按照需要交换两个元素的位置;起泡排序的最坏情况为逆序输入,比较次数为11(1)()2n i n n C n i -=-==∑。

(b) 最好情况为已排序,需要(n-1)次比较。

4.3:(a)归纳法:当n=1时显然成立,当n=2时经过一次起泡后,也显然最大元素位于末尾;现假设当n=k-1是,命题也成立,则当n=k时,对前k-1个元素经过一次起泡后,根据假设显然第k-1个元素是前k-1个元素中最大的,现在根据起泡定义它要同第k个元素进行比较,当k元素大于k-1元素时,它为k个元素中最大的,命题成立;当k元素小于k-1元素时,它要同k-1交换,这时处于队列末尾的显然时队列中最大的元素。

综上所述,当n=k时命题成立。

中科院计算机算法设计与分析各章作业+历年习题

中科院计算机算法设计与分析各章作业+历年习题

5.下面那些规则是正确的?为什么? 1). f (n) O( F (n)), g (n) O(G(n)) f (n) / g (n) O( F (n) / G(n)) ;错 2). f (n) O( F (n)), g (n) O(G(n)) f (n) / g (n) ( F (n) / G(n)) ;错 3). f (n) O( F (n)), g (n) O(G(n)) f (n) / g (n) ( F (n) / G(n)) ;错 4). f (n) ( F (n)), g (n) (G(n)) f (n) / g (n) ( F (n) / G(n)) ;错 5). f (n) ( F (n)), g (n) (G(n)) f (n) / g (n) ( F (n) / G(n)) 。错 6).
7
对顶点个数进行归纳。 当顶点数|v(D)|=2 时,因为每个点的入度和出度相等,易得构成有向 Euler 环游。 假设顶点数|v(D)|=k 时结论成立,则 当顶点数|v(D)|=k + 1 时,任取 v∈v(D).设 S={以 v 为终点的边},K={以 v 为始点的边},因为 v 的入度和出度相等,故 S 和 K 中边数相等。记 G=D-v.对 G 做如下操作: 任取 S 和 K 中各一条边 e1、e2 ,设在 D 中 e1 v1v , e2 vv2 ,则对 G 和 S 做如下操作 G G v1v2 , S S {e2} ,重复此步骤直到 S 为空。这个过程最终 得到的 G 有 k 个顶点,且每个顶点的度与在 G 中完全一样。由归纳假设,G 中 存在有向 Euler 环游,设为 C。在 G 中从任一点出发沿 C 的对应边前行,每当遇 到上述添加边 v1v2 时, 都用对应的两条边 e1, e2 代替, 这样可以获得有向 Euler 环游。 3)G 是至少有三个顶点的无向图,则 G 包含 Euler 环游等价于 G 中无奇度顶 点。 (即任意顶点的度为偶数) 。 3. 设 G 是具有 n 个顶点和 m 条边的无向图, 如果 G 是连通的, 而且满足 m = n-1, 证明 G 是树。

2020年算法分析设计习题答案

2020年算法分析设计习题答案

第3章 动态规划
2. 石子合并问题 问题描述: 在一个圆形操场的四周摆放着n堆石子. 现在要将石子有次序地合并 成一堆. 规定每次只能选相邻的2堆石子合并成一堆, 并将新的一堆石子数记为 该次合并的得分. 试设计一个算法, 计算出将n堆石子合并成一堆的最小得分和 最大得分. 算法设计: 对于给定n堆石子, 计算合并成一堆的最小得分和最大得分. 数据输入: 由文件input.txt提供输入数据. 文件的第1行是正整数n, 1n100, 表 示有n堆石子. 第2行有n个数, 分别表示n堆石子的个数. 结果输出: 将计算结果输出到文件output.txt, 文件第1行是最小得分, 第2行是最 大得分.
第五章 回溯
运动员最佳配对问题
问题描述: 羽毛球队有男女运动员各n人. 给定2个nn矩阵P和Q. P[i][j]是男运 动员i与女运动员j配混合双打的男运动员竞赛优势; Q[i][j]是女运动员i与男运 动员j配混合双打的女运动员竞赛优势. 由于技术配合和心理状态等各种因素 影响, P[i][j]不一定等于Q[j][i]. 男运动员i和女运动员j配对的竞赛优势是 P[i][j]*Q[j][i]. 设计一个算法, 计算男女运动员最佳配对法, 使得各组男女双方 竞赛优势的总和达到最大.
8.
若m[i,j]>t, 则m[i,j]=t; s[i,j]=k;
第3章 动态规划
再讨论圆周上的石子合并问题, 子结构[i:j]稍作修改 • 定义m[i][len]为合并第i堆到第i+len-1堆石子能得到的最少分数 • 当i+len-1>n时, 指跨过第n堆到第(i+len-1)%n堆,
仅sum函数需要修改
第2章 分治
2-8 设n个不同的整数排好序后存于T[1:n]中. 若存在一个下标i, 1 i n, 使得T[i]=i. 设计一个有效算法找到这个下标. 要求算 法在最坏情况下的计算时间O(log n).

算法分析与设计智慧树知到答案章节测试2023年黑龙江工程学院

算法分析与设计智慧树知到答案章节测试2023年黑龙江工程学院

第一章测试1.算法就是一组有穷的规则,它们规定了解决某一特定类型问题的一系列运算。

()A:对B:错答案:A2.计算机的资源最重要的是内存和运算资源。

因而,算法的复杂性有时间和空间之分。

()A:对B:错答案:A3.时间复杂度是指算法最坏情况下的运行时间。

()A:对B:错答案:B4.下面关于算法的说法中正确的是。

(1)求解某一问题的算法是唯一的。

(2)算法中每条指令的执行次数是有限的,执行每条指令的时间也是有限的。

(3)算法的每一条指令是清晰无歧义的。

(4)算法可以用某种程序设计语言具体实现,所以算法和程序是等价的。

()A:(2)(3)B:(1)(3)C:(1)(2)D:(2)(4)答案:A5.描述算法的基本方法有。

(1)自然语言(2)流程图(3)伪代码(4)程序设计语言()A:(1)(2)(3)B:(1)(3)(4)C:(1)(2)(3)(4)D:(2)(3)(4)答案:C6.算法分析是()A:将算法用某种程序设计语言恰当地表示出来B:证明算法对所有可能的合法出入都能算出正确的答案C:对算法需要多少计算时间和存储空间作定量分析D:在抽象数据数据集合上执行程序,以确定是否产生错误结果答案:C7.算法是由若干条指令组成的有穷序列,而且满足以下叙述中的性质。

(1)输入:有0个或多个输入(2)输出:至少有一个输出(3)确定性:指令清晰、无歧义(4)有限性:指令执行次数有限,而且执行时间有限()A:(1)(2)(3)B:(1)(2)(4)C:(1)(2)(3)(4)D:(1)(3)(4)答案:C8.下面函数中增长率最低的是()A:n2B:log2nC:nD:2n答案:B9.下面属于算法的特性有( )。

A:有限性:算法中每条指令的执行次数是有限的,执行每条指令的时间也是有限的。

B:输入:有0个或多个外部量作为算法的输入。

C:确定性:组成算法的每条指令是清晰,无歧义的。

D:输出:算法产生至少一个量作为输出。

答案:ABCD10.当m为24,n为60时,使用欧几里得算法求m和n的最大公约数,需要进行()次除法运算。

算法分析与设计(习题答案)

算法分析与设计(习题答案)

算法分析与设计教程习题解答第1章 算法引论1. 解:算法是一组有穷的规则,它规定了解决某一特定类型问题的一系列计算方法。

频率计数是指计算机执行程序中的某一条语句的执行次数。

多项式时间算法是指可用多项式函数对某算法进行计算时间限界的算法。

指数时间算法是指某算法的计算时间只能使用指数函数限界的算法。

2. 解:算法分析的目的是使算法设计者知道为完成一项任务所设计的算法的优劣,进而促使人们想方设法地设计出一些效率更高效的算法,以便达到少花钱、多办事、办好事的经济效果。

3. 解:事前分析是指求出某个算法的一个时间限界函数(它是一些有关参数的函数);事后测试指收集计算机对于某个算法的执行时间和占用空间的统计资料。

4. 解:评价一个算法应从事前分析和事后测试这两个阶段进行,事前分析主要应从时间复杂度和空间复杂度这两个维度进行分析;事后测试主要应对所评价的算法作时空性能分布图。

5. 解:①n=11; ②n=12; ③n=982; ④n=39。

第2章 递归算法与分治算法1. 解:递归算法是将归纳法的思想应用于算法设计之中,递归算法充分地利用了计算机系统内部机能,自动实现调用过程中对于相关且必要的信息的保存与恢复;分治算法是把一个问题划分为一个或多个子问题,每个子问题与原问题具有完全相同的解决思路,进而可以按照递归的思路进行求解。

2. 解:通过分治算法的一般设计步骤进行说明。

3. 解:int fibonacci(int n) {if(n<=1) return 1;return fibonacci(n-1)+fibonacci(n-2); }4. 解:void hanoi(int n,int a,int b,int c) {if(n>0) {hanoi(n-1,a,c,b); move(a,b);hanoi(n-1,c,b,a); } } 5. 解:①22*2)(−−=n n f n② )log *()(n n n f O =6. 解:算法略。

算法设计与分析报告习题

算法设计与分析报告习题

《算法设计与分析》习题第一章算法引论1、算法的定义?答:算法是指在解决问题时,按照某种机械步骤一定可以得到问题结果的处理过程。

通俗讲,算法:就是解决问题的方法或过程。

2、算法的特征?答:1)算法有零个或多个输入;2)算法有一个或多个输出; 3)确定性;4)有穷性3、算法的描述方法有几种?答:自然语言、图形、伪代码、计算机程序设计语言4、衡量算法的优劣从哪几个方面?答:(1) 算法实现所耗费的时间(时间复杂度);(2) 算法实现所所耗费的存储空间(空间复杂度);(3) 算法应易于理解,易于编码,易于调试等等。

5、时间复杂度、空间复杂度定义?答:指的是算法在运行过程中所需要的资源(时间、空间)多少。

6、时间复杂度计算:{i=1;while(i<=n)i=i*2; }答:语句①执行次数1次,语句②③执行次数f(n), 2^f(n)<=n,则f(n) <=log2n;算法执行时间: T(n)= 2log2n +1时间复杂度:记为O(log2n) ;7.递归算法的特点?答:①每个递归函数都必须有非递归定义的初值;否则,递归函数无法计算;(递归终止条件)②递归中用较小自变量函数值来表达较大自变量函数值;(递归方程式)8、算法设计中常用的算法设计策略?答:①蛮力法;②倒推法;③循环与递归;④分治法;⑤动态规划法;⑥贪心法;⑦回溯法;⑧分治限界法9、设计算法:递归法:汉诺塔问题?兔子序列(上楼梯问题)?整数划分问题?蛮力法:百鸡百钱问题?倒推法:穿越沙漠问题?答:算法如下: (1) 递归法● 汉诺塔问题void hanoi(int n, int a, int b, int c) {if (n > 0) {hanoi(n-1, a, c, b); move(a,b);hanoi(n-1, c, b, a); } }● 兔子序列(fibonaci 数列 )递归实现:Int F(int n) {if(n<=2) return 1; elsereturn F(n-1)+ F(n-2); }● 上楼梯问题 Int F(int n) {if(n=1) return 1 if(n=2) return 2; elsereturn F(n-1)+ F(n-2); }● 整数划分问题问题描述:将正整数n 表示成一系列正整数之和,n=n1+n1+n3+…将最大加数不大于m 的划分个数,记作q(n,m)。

算法设计与分析课后习题解答

算法设计与分析课后习题解答
令c1=min(a1,b1),c2=max(a2,b2),则
C1*(g1+g2)<= t1(n)+t2(n) <=c2(g1+g2)—----(3)
不失一般性假设max(g1(n),g2(n))=g1(n)。
显然,g1(n)+g2(n)<2g1(n),即g1+g2〈2max(g1,g2)
又g2(n)〉0,g1(n)+g2(n)>g1(n),即g1+g2>max(g1,g2).
算法设计与分析基础课后练习答案
习题1.1
4。设计一个计算 的算法,n是任意正整数。除了赋值和比较运算,该算法只能用到基本的四则运算操作。
算法求
//输入:一个正整数n 2
//输出:。
step1:a=1;
step2:若a*a<n转step 3,否则输出a;
step3:a=a+1转step 2;
5. a.用欧几里德算法求gcd(31415,14142)。
b。该算法稳定吗?
c.该算法在位吗?
解:
a。该算法对列表”60,35,81,98,14,47”排序的过程如下所示:
b.该算法不稳定.比如对列表"2,2*”排序
c.该算法不在位.额外空间for S and Count[]
4.(古老的七桥问题)
第2章
习题2。1
7。对下列断言进行证明:(如果是错误的,请举例)
Else return A[n—1]
a.该算法计算的是什么?
b.建立该算法所做的基本操作次数的递推关系并求解
解:
a.计算的给定数组的最小值
b.
9。考虑用于解决第8题问题的另一个算法,该算法递归地将数组分成两半。我们将它称为Min2(A[0..n-1])

算法设计与分析习题答案1-6章

算法设计与分析习题答案1-6章

习题11.图论诞生于七桥问题。

出生于瑞士的伟大数学家欧拉(Leonhard Euler ,1707—1783)提出并解决了该问题。

七桥问题是这样描述的:一个人是否能在一次步行中穿越哥尼斯堡(现在叫加里宁格勒,在波罗的海南岸)城中全部的七座桥后回到起点,且每座桥只经过一次,图1.7是这条河以及河上的两个岛和七座桥的草图。

请将该问题的数据模型抽象出来,并判断此问题是否有解。

七桥问题属于一笔画问题。

输入:一个起点 输出:相同的点 1, 一次步行2, 经过七座桥,且每次只经历过一次 3, 回到起点该问题无解:能一笔画的图形只有两类:一类是所有的点都是偶点。

另一类是只有二个奇点的图形。

2.在欧几里德提出的欧几里德算法中(即最初的欧几里德算法)用的不是除法而是减法。

请用伪代码描述这个版本的欧几里德算法 1.r=m-n2.循环直到r=0 2.1 m=n 2.2 n=r 2.3 r=m-n 3 输出m3.设计算法求数组中相差最小的两个元素(称为最接近数)的差。

要求分别给出伪代码和C ++描述。

//采用分治法//对数组先进行快速排序 //在依次比较相邻的差 #include <iostream> using namespace std;int partions(int b[],int low,int high) {图1.7 七桥问题int prvotkey=b[low];b[0]=b[low];while (low<high){while (low<high&&b[high]>=prvotkey)--high;b[low]=b[high];while (low<high&&b[low]<=prvotkey)++low;b[high]=b[low];}b[low]=b[0];return low;}void qsort(int l[],int low,int high){int prvotloc;if(low<high){prvotloc=partions(l,low,high); //将第一次排序的结果作为枢轴 qsort(l,low,prvotloc-1); //递归调用排序由low 到prvotloc-1qsort(l,prvotloc+1,high); //递归调用排序由 prvotloc+1到 high}}void quicksort(int l[],int n){qsort(l,1,n); //第一个作为枢轴,从第一个排到第n个}int main(){int a[11]={0,2,32,43,23,45,36,57,14,27,39};int value=0;//将最小差的值赋值给valuefor (int b=1;b<11;b++)cout<<a[b]<<' ';cout<<endl;quicksort(a,11);for(int i=0;i!=9;++i){if( (a[i+1]-a[i])<=(a[i+2]-a[i+1]) )value=a[i+1]-a[i];elsevalue=a[i+2]-a[i+1];}cout<<value<<endl;return 0;}4.设数组a[n]中的元素均不相等,设计算法找出a[n]中一个既不是最大也不是最小的元素,并说明最坏情况下的比较次数。

智慧树知到《算法分析与设计》章节测试答案

智慧树知到《算法分析与设计》章节测试答案

智慧树知到《算法分析与设计》章节测试答案第一章1、给定一个实例,如果一个算法能得到正确解答,称这个算法解答了该问题。

A:对B:错答案: 错2、一个问题的同一实例可以有不同的表示形式A:对B:错答案: 对3、同一数学模型使用不同的数据结构会有不同的算法,有效性有很大差别。

A:对B:错答案: 对4、问题的两个要素是输入和实例。

A:对B:错答案: 错5、算法与程序的区别是()A:输入B:输出C:确定性D:有穷性答案: 有穷性6、解决问题的基本步骤是()。

(1)算法设计(2)算法实现(3)数学建模(4)算法分析(5)正确性证明A:(3)(1)(4)(5)(2)B:(3)(4)(1)(5)(2)C:(3)(1)(5)(4)(2)D:(1)(2)(3)(4)(5)答案: (3)(1)(5)(4)(2)7、下面说法关于算法与问题的说法错误的是()。

A:如果一个算法能应用于问题的任意实例,并保证得到正确解答,称这个算法解答了该问题。

B:算法是一种计算方法,对问题的每个实例计算都能得到正确答案。

C:同一问题可能有几种不同的算法,解题思路和解题速度也会显著不同。

D:证明算法不正确,需要证明对任意实例算法都不能正确处理。

答案: 证明算法不正确,需要证明对任意实例算法都不能正确处理。

8、下面关于程序和算法的说法正确的是()。

A:算法的每一步骤必须要有确切的含义,必须是清楚的、无二义的。

B:程序是算法用某种程序设计语言的具体实现。

C:程序总是在有穷步的运算后终止。

D:算法是一个过程,计算机每次求解是针对问题的一个实例求解。

答案: 算法的每一步骤必须要有确切的含义,必须是清楚的、无二义的。

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

,算法是一个过程,计算机每次求解是针对问题的一个实例求解。

9、最大独立集问题和()问题等价。

A: 最大团B:最小顶点覆盖C:区间调度问题D:稳定匹配问题答案:最大团,最小顶点覆盖10、给定两张喜欢列表,稳定匹配问题的输出是()。

算法设计与分析(安徽理工大学)智慧树知到答案章节测试2023年

算法设计与分析(安徽理工大学)智慧树知到答案章节测试2023年

第一章测试1.算法的重要特性( )。

A:能行性B:输出C:有穷性D:确定性E:输入答案:ABCDE2.语句 return sum(x,y);执行频度为1 ( )A:对B:错答案:B3.的上界函数是 ( )A:对B:错答案:A4.算法时间复杂度为O(1)说明算法执行时间是单位时间( )A:对B:错答案:B5.集合的位向量表示法,合并集合操作的时间复杂度为( )A:B:C:D:答案:A6.带加权规则的Union算法中,Parent(1)=-8,Parent(2)=-4,1、2代表的集合合并后,集合的根是1,Parent(1)=-12,Parent(2)=1( )A:对B:错答案:A7.写一个算法交换两个变量x、y的值不使用第三个变量。

答案:8.求下列函数的渐进表达式:; ; ;答案:9.的渐进表达式=____答案:10.按照渐进阶从低到高的顺序排列以下表达式:,,, ,,,。

答案:第二章测试1.递归程序每一次递归执行的语句都完全相同( )A:对B:错答案:B2.对数组ary[0:n-1]求和,采用如下递归方式:arysum(n)=ary[n-1]+arysum(n-1),递归方式是( )A:线性递归B:非线性递归答案:A3.问题规模为的全排列问题,可以看作个规模为的全排列问题,因此时间复杂度为: ( )A:错B:对答案:B4.递归程序简洁明了,因此比非递归程序执行效率高( )A:错B:对答案:A5.Master Method适应于求解形式如T(n)=aT(n/b)+f(n)的递归关系式。

其中,a表示子问题个数, n/b子问题规模,f(n)表示划分子问题或整合子问题解的时间。

( )A:对B:错答案:A6.递归关系式:F(n)=F(n-1)+F(n-2)+1是二阶齐次常系数线性递归式。

( )A:错B:对答案:A7.解形式为( )(p均为待定系数):A:B:C:D:答案:C8.求解非线性变系数递归关系式一个原则是“变换”,经过变换将其转换为线性常系数等常规可求的递归式。

计算机算法设计与分析(王晓东第4版)第4章

计算机算法设计与分析(王晓东第4版)第4章
School of Computer and Communication Engineer 30
23
最优解代价公式
c[i, j ]: Sij 最优解的大小 c[i, j ] = 0 if Sij = φ maxak ∈Sij {c[i, k ] + c[k, j ] + 1} if Sij = φ
School of Computer and Communication Engineer
24
活动选择问题动态规划方法
schoolcommunicationengineer一步一步构建问题的最优解决方案其中每一步只考虑眼前的最佳选择对解空间进行搜索时在局部范围内进行择优选取决定下一步搜索方向不是为了找到全部解而只是找出一种可行解在一定的情况下贪心算法找出的可行解将是最优解schoolcommunicationengineer42贪贪贪心心心算算算法法法基基基本本本要要要素素素算法包含一系列步骤每一步都有一组选择做出在当前看来最好的选择一个贪心算法是否产生最优解需要严格证明schoolcommunicationengineer最优子结构schoolcommunicationengineer贪贪贪心心心选选选择择择性性性质质质定定定义义义若若若一个优化问题的全局最优解可以通过局部最优选择得到则该问题称为具有贪贪贪心心心选选选择择择性性性
School of Computer and Communication Engineer 4
4.2 贪 心 算 法 基 本 要 素
• 算法包含一系列步骤, 每一步都有一组选择, 做出在 当前看来最好的选择 • 希望通过作出局部最优选择达到全局最优选择 • 一个贪心算法是否产生最优解, 需要严格证明
School of Computer and Communication Engineer
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
a=a-m;
}
return 0;
}
4.
#include<stdio.h>
int d;
int a1,a2;
int fun(int n);
int main(void)
{
int n;
printf("n=?,d=?,a1=?,a2=?");
scanf("%d%d%d%d\n",&n,&d,&a1,&a2);
{
*max1=lmax1;
*max2=lmax2;
}
else
{
*max1=lmax1;
*max2=rmax1;
}
}
else
if(rmax2>lmax1)
continue;
}
a=a-n;
printf("还剩%d张牌\n",a);
if(a==0)
break;
m=5-n;
printf("计算机拿%d\n",m);
{
*min1=lmin1;
*min2=lmin2;
}
else
{
*min1=lmin1;
*min2=rmin1;
}
}
else
if(rmin2<lmin1)
chess[i][j]='X';
queen(0,0,0);
for(i=0;i<8;i++)
{
for(j=0;j<8;j++)
printf("%c ",chess[i][j]);
printf("\n");
}
return 0;
}
i=row;
j=col;
while(i!=-1&&j!=-1)
{
if(chess[i--][j--]=='Q')
return 0;
}
i=row;
j=col;
while(i!=-1&&j!=8)
{
printf("%d\n",fun(n));
return 0;
}
int fun(int n)
{
if(n==1)
return a1;
if(n==2)
return a2;
return fun(n-2)-(fun(n-1)-d)*2;
算法设计与分析(第二版)
主编:吕国英
习题答案
第四章
1.
#include<stdio.h>
int main(void)
{
int buf[100];
int n;
int i,j,k;
scanf("%d",&n);
for(i=0;i<n;i++)
{ buf[i]=2;
{
if(buf[j]>=10)
{
buf[j+1]+=buf[j]/10;
buf[j]=buf[j]%10;
}
}
}
for(i=n-1;i>=0;i--)
printf("%d",buf[i]);
printf("\n");
return 0;
}
2.
#include<stdio.h>
int main(void)
{
int n=2;
int i;
for(i=1;i<=9;i++)
{
n=(n+2)*2;
int mid;
if(m==n)
{
*min1=*min2=*max1=*max2=a[m];
}
else
if(m==n-1)
{
if(a[m]<a[n])
{
*min1=a[m];
*min2=a[n];
}
int is_safe(int row,int col)
{
int i,j;
for(i=0;i<8;i++)
{
if(chess[row][i]=='Q')
return 0;
if(chess[i][col]=='Q')
return 0;
{
k=100-i-j;
if(k%2==0)
{
if(3*i+2*j+k/2==100)
printf("大马%d\n中马%d\n小马%d\n\n\n",i,j,k);
}
}
return 0;
}
7.
#include<stdio.h>
}
i=row;
j=col;
while(i!=8&&j!=8)
{
if(chess[i++][j++]=='Q')
return 0;
}
return 1;
}
int queen(int row,int col,int n)
{
for(i=0;i<n-1;i++)
{
for(j=0;j<n-i-1;j++)
{
buf[j]+=2;
}
}
for(j=0;j<n;j++)
{
mid=(m+n)/2;
max_min(a,m,mid,&lmin1,&lmin2,&lmax1,&lmax2);
max_min(a,mid+1,n,&rmin1,&rmin2,&rmax1,&rmax2);
if(lmin1<rmin1)
{
if(lmin2<rmin1)
{
*max1=rmax1;
*max2=rmax2;
}
else
{
{
a4=i/1000;
if(a1!=a4&&a2!=a4&&a3!=a4)
{
sum=(a1+a2+a3+a4)*(a1+a2+a3+a4);
if(i%sum==0)
printf("%d\n",i);
}
}
}
printf("%d\n",n);
return 0;
}
3.
#include<stdio.h>
int main(void)
{
int a=54;
int n;
int m;
printf("计算机先拿3张牌\n");
a=a-3;
while(a>=0)
{
int main(void)
{
int i;
int sum;
int a1,a2,a3,a4;
for(i=1000;i<=9999;i++)
{
a1=i%10;
a2=i/10%10;
if(a1!=a2)
{
a3=i/100%10;
if(a1!=a3&&a2!=a3)
{
*min1=rmin1;
*min2=rmin2;
}
else
{
*min1=rmin1;
*min2=lmin1;
}
if(lmax1>rmax1)
{
if(lmax2>rmax1)
{
result+=queen(i,j,n+1);
if(result>0)
break;
}
if(result>0) return 1;
else
{
chess[row][col]='X';
}
5.
#include<stdio.h>
char chess[8][8];
int is_safe(int row,int col);
int queen(int row,int col,int n);
int main(void)
{
int i,j;
for(i=0;i<8;i++)
for(j=0;j<8;j++)
*max1=a[n];
*max2=a[m];
}
else
{
*min1=a[n];
*min2=a[m];
*max1=a[m];
*max2=a[n];
}
} eLeabharlann se printf("还剩%d张牌\n",a);
printf("你拿几张?请输入:");
scanf("%d",&n);
相关文档
最新文档