厦门理工算法设计与分析(第四章)

合集下载

计算机算法设计与分析课程设计

计算机算法设计与分析课程设计成绩评定表课程设计任务书算法分析是对一个算法需要多少计算时间和存储空间作定量的分析。

算法（Algorithm）是解题的步骤，可以把算法定义成解一确定类问题的任意一种特殊的方法。

在计算机科学中，算法要用计算机算法语言描述，算法代表用计算机解一类问题的精确、有效的方法。

分治法字面上的解释是“分而治之”，就是把一个复杂的问题分成两个或更多的相同或相似的子问题，再把子问题分成更小的子问题……直到最后子问题可以简单的直接求解，原问题的解即子问题的解的合并。

在一个2^k*2^k的棋盘上，恰有一个放歌与其他方格不同，且称该棋盘为特殊棋盘。

回溯法的基本做法是深度优先搜索，是一种组织得井井有条的、能避免不必要重复搜索的穷举式搜索算法。

数字拆分问题是指将一个整数划分为多个整数之和的问题。

利用回溯法可以很好地解决数字拆分问题。

将数字拆分然后回溯，从未解决问题。

关键词：分治法，回溯法，棋盘覆盖，数字拆分1分治法解决期盼覆问题 (1)1.1问题描述 (1)1.2问题分析 (1)1.3算法设计 (1)1.4算法实现 (2)1.5结果分析 (3)1.6算法分析 (4)2回溯法解决数字拆分问题 (6)2.1问题描述 (6)2.2问题分析 (6)2.3算法设计 (7)2.4算法实现 (7)2.5结果分析 (8)参考文献 (9)1分治法解决期盼覆问题1.1问题描述在一个2k×2k（k≥0）个方格组成的棋盘中，恰有一个方格与其他方格不同，称该方格为特殊方格。

显然，特殊方格在棋盘中出现的位置有4k中情形，因而有4k中不同的棋盘，图（a）所示是k=2时16种棋盘中的一个。

棋盘覆盖问题要求用图（b）所示的4中不同形状的L型骨牌覆盖给定棋盘上除特殊方格以外的所有方格，且热河亮哥L型骨牌不得重复覆盖1.2问题分析用分治策略，可以设计解决棋盘问题的一个简介算法。

当k>0时，可以将2^k*2^k棋盘分割为4个2^k-1*2^k-1子棋盘。

厦门理工学院算法期末复习

} }
分治法-适用条件
分治法所能解决的问题一般具有以下几个特征：该问题的规模缩小到一定的程度就可以容易地解决；该问题可以分解为若干个规模较小的相同问题，即该问题具有最优子结构性质利用该问题分解出的子问题的解可以合并为该问题的解；该问题所分解出的各个子问题是相互独立的，即子问题之间丌包含公共的子问题。
if (t < u) {
u = t; s[i][j] = k;}
}
m[i][j] = u;
return u;
}
28
矩阵连乘
给定n个矩阵：A1, A2, …, An，其中Ai不Ai+1是可乘的。确定一种连乘的顺序，使得矩阵连乘的计算量为最小设A和B分别是p×q和q×r的矩阵，则乘积C=AB为p×r的矩阵，计算量为pqr次数乘但是对于多于2个以上的矩阵连乘，连乘的顺序却非常重要，因为丌同的顺序的总计算量将会有徆大的差别
return middle;
if (x > a[middle]) left = middle + 1;
else right = middle - 1;
}
return -1; // 未找到x
}
迭代
else if(a[middle]>num)
return binarySearch(a,num,left,middle-1) ;
public static void mergeSort(Comparable a[], int left, int right)
{
if (left<right) {//至少有2个元素
int i=(left+right)/2; //取中点
mergeSort(a, left, i);

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

算法分析与设计教程习题解答第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.#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;for(i=0;i<n-1;i++){for(j=0;j<n-i-1;j++){buf[j]+=2;}}for(j=0;j<n;j++){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;}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){printf("还剩%d张牌\n",a); printf("你拿几张？请输入："); scanf("%d",&n);if(n>4||n<1||n>a){printf("错误！重新拿牌\n"); continue;}a=a-n;printf("还剩%d张牌\n",a);if(a==0)break;m=5-n;printf("计算机拿%d\n",m);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); 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; }}。

《算法设计与分析》课程实验与设计福州大学王晓东

《算法设计与分析》课程实验与设计福州大学王晓东第1章算法引论算法实现题1-1 统计数字问题算法实现题1-2 字典序问题算法实现题1-3 最多约数问题算法实现题1-4 金币阵列问题算法实现题1-5 最大间隙问题第2章递归与分治策略算法实现题2-1 输油管道问题算法实现题2-2 众数问题算法实现题2-3 邮局选址问题算法实现题2-4 马的Hamilton周游路线问题算法实现题2-5 半数集问题算法实现题2-6 半数单集问题算法实现题2-7 士兵站队问题算法实现题2-8 有重复元素的排列问题算法实现题2-9 排列的字典序问题算法实现题2-10 集合划分问题算法实现题2-11 集合划分问题2算法实现题2-12 双色Hanoi塔问题算法实现题2-13 标准2维表问题算法实现题2-14 整数因子分解问题算法实现题2-15 有向直线2中值问题第3章动态规划算法实现题3-1 独立任务最优调度问题算法实现题3-2 最少硬币问题算法实现题3-3 序关系计数问题算法实现题3-4 多重幂计数问题算法实现题3-5 编辑距离问题算法实现题3-6 石子合并问题算法实现题3-7 数字三角形问题算法实现题3-8 乘法表问题算法实现题3-9 租用游艇问题算法实现题3-10 汽车加油行驶问题算法实现题3-11 圈乘运算问题算法实现题3-12 最少费用购物算法实现题3-13 最大长方体问题算法实现题3-14 正则表达式匹配问题算法实现题3-15 双调旅行售货员问题算法实现题3-16 最大k乘积问题算法实现题3-17 最小m段和问题算法实现题3-18 红黑树的红色内结点问题第4章贪心算法算法实现题4-1 会场安排问题算法实现题4-2 最优合并问题算法实现题4-3 磁带最优存储问题算法实现题4-4 磁盘文件最优存储问题算法实现题4-6 最优服务次序问题算法实现题4-7 多处最优服务次序问题算法实现题4-8 d森林问题算法实现题4-9 汽车加油问题算法实现题4-10 区间覆盖问题算法实现题4-11 硬币找钱问题算法实现题4-12 删数问题算法实现题4-13 数列极差问题算法实现题4-14 嵌套箱问题算法实现题4-15 套汇问题算法实现题4-16 信号增强装置问题算法实现题4-17 磁带最大利用率问题算法实现题4-18 非单位时间任务安排问题算法实现题4-19 多元Huffman编码问题算法实现题4-20 多元Huffman编码变形算法实现题4-21 区间相交问题算法实现题4-22 任务时间表问题第5章回溯法算法实现题5-1 子集和问题算法实现题5-2 最小长度电路板排列问题算法实现题5-3 最小重量机器设计问题算法实现题5-4 运动员最佳匹配问题算法实现题5-5 无分隔符字典问题算法实现题5-6 无和集问题算法实现题5-7 n色方柱问题算法实现题5-9 拉丁矩阵问题算法实现题5-10 排列宝石问题算法实现题5-11 重复拉丁矩阵问题算法实现题5-12 罗密欧与朱丽叶的迷宫问题算法实现题5-13 工作分配问题算法实现题5-14 独立钻石跳棋问题算法实现题5-15 智力拼图问题算法实现题5-16 布线问题算法实现题5-17 最佳调度问题算法实现题5-18 无优先级运算问题算法实现题5-19 世界名画陈列馆问题算法实现题5-20 世界名画陈列馆问题（不重复监视）算法实现题5-21 部落卫队问题算法实现题5-22 虫蚀算式问题算法实现题5-23 完备环序列问题算法实现题5-24 离散01串问题算法实现题5-25 喷漆机器人问题算法实现题5-26 n2-1谜问题第6章分支限界法算法实现题6-1 最小长度电路板排列问题算法实现题6-2 最小长度电路板排列问题算法实现题6-3 最小权顶点覆盖问题算法实现题6-4 无向图的最大割问题算法实现题6-5 最小重量机器设计问题算法实现题6-6 运动员最佳匹配问题算法实现题6-7 n皇后问题算法实现题6-8 圆排列问题算法实现题6-9 布线问题算法实现题6-10 最佳调度问题算法实现题6-11 无优先级运算问题算法实现题6-12 世界名画陈列馆问题算法实现题6-13 骑士征途问题算法实现题6-14 推箱子问题算法实现题6-15 图形变换问题算法实现题6-16 行列变换问题算法实现题6-17 重排n2宫问题算法实现题6-18 最长距离问题第7章概率算法算法实现题7-1 模平方根问题算法实现题7-2 素数测试问题算法实现题7-3 集合相等问题算法实现题7-4 逆矩阵问题算法实现题7-5 多项式乘积问题算法实现题7-6 皇后控制问题算法实现题7-7 3SAT问题算法实现题7-8 战车问题算法实现题7-9 圆排列问题算法实现题7-10 骑士控制问题算法实现题7-11 骑士对攻问题第9章近似算法算法实现题9-1旅行售货员问题的近似算法算法实现题9-2 可满足问题的近似算法算法实现题9-3 最大可满足问题的近似算法算法实现题9-4 子集和问题的近似算法算法实现题9-5 子集和问题的完全多项式时间近似算法算法实现题9-6 实现算法greedySetCover算法实现题9-7 装箱问题的近似算法First Fit算法实现题9-8 装箱问题的近似算法Best Fit算法实现题9-9 装箱问题的近似算法First Fit Decreasing 算法实现题9-10 装箱问题的近似算法Best Fit Decreasing 算法实现题9-11 装箱问题的近似算法Next Fit第10章算法优化策略算法实现题10-1 货物储运问题算法实现题10-2 石子合并问题算法实现题10-3 最大运输费用货物储运问题算法实现题10-4 五边形问题算法实现题10-5 区间图最短路问题算法实现题10-6 圆弧区间最短路问题算法实现题10-7 双机调度问题算法实现题10-8 离线最小值问题算法实现题10-9 最近公共祖先问题算法实现题10-10 达尔文芯片问题算法实现题10-11 多柱Hanoi塔问题算法实现题10-12 线性时间Huffman算法算法实现题10-13 单机调度问题算法实现题10-14 最大费用单机调度问题算法实现题10-15 飞机加油问题《算法设计与分析》期中试卷1 试题1 数列极差问题试题2 双调TSP回路问题试题3 最佳调度问题《算法设计与分析》期中试卷2 试题1 石子合并问题试题2 整数因子分解问题试题3 汽车加油问题《算法设计与分析》期终试卷1 试题1 乘法表问题试题2 工作分配问题试题3 飞行员配对方案问题《算法设计与分析》期终试卷2 试题1 直线k中值问题试题2 图形变换问题试题3 无向图的最大割问题。

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

算法设计与分析智慧树知到课后章节答案2023年下山东交通学院山东交通学院第一章测试1.解决一个问题通常有多种方法。

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

请问农夫能不能过去？（）A:不一定B:不能过去 C:能过去答案:能过去3.下述（）不是是算法的描述方式。

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

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

（）A:对 B:错答案:对6.程序=数据结构+算法（）A:对 B:错答案:对7.同一个问题可以用不同的算法解决，同一个算法也可以解决不同的问题。

（）A:错 B:对答案:对8.算法中的每一条指令不需有确切的含义，对于相同的输入不一定得到相同的输出。

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

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

（）A:对 B:错答案:对12.算法与程序没有关系。

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

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

厦门理工_算法设计与分析_模拟试卷二

一、排序和查找是经常遇到的问题。

按照要求完成以下各题：（20分）（1）对数组A={15，29，135，18，32，1，27，25，5}，用快速排序方法将其排成递减序。

（2）请描述递减数组进行二分搜索的基本思想，并给出非递归算法。

（3）给出上述算法的递归算法。

（4）使用上述算法对（1）所得到的结果搜索如下元素，并给出搜索过程：18，31，135。

答案：（1）第一步：15 29 135 18 32 1 27 25 5第二步：29 135 18 32 27 25 15 1 5 【1分】第三步：135 32 29 18 27 25 15 5 1 【1分】第四步：135 32 29 27 25 18 15 5 1 【1分】（2）基本思想：首先将待搜索元素v与数组的中间元素进行比较，如果，则在前半部分元素中搜索v；若，则搜索成功；否则在后半部分数组中搜索v。

【2分】非递归算法：输入：递减数组A[left:right]，待搜索元素v。

【1分】输出：v在A中的位置pos，或者不在A中的消息（-1）。

【1分】步骤：【3分】int BinarySearch(int A[],int left,int right,int v){int mid;while (left<=right){mid=int((left+right)/2);if (v==A[mid]) return mid;else if (v>A[mid]) right=mid-1;else left=mid+1;}return -1;}（3）递归算法：输入：递减数组A[left:right]，待搜索元素v。

【1分】输出：v在A中的位置pos，或者不在A中的消息（-1）。

【1分】步骤：【3分】int BinarySearch(int A[],int left,int right,int v){int mid;if (left<=right){mid=int((left+right)/2);if (v==A[mid]) return mid;else if (v>A[mid]) return BinarySearch(A,left,mid-1,v);else return BinarySearch(A,mid+1,right,v);}elsereturn -1;}（4）搜索18：首先与27比较，18<27，在后半部分搜索；再次与18比较，搜索到，返回5。

算法设计与分析 ppt

算法设计与分析 >目录
第一章算法概述第二章递归与分治策略第三章动态规划第四章贪心算法第五章回朔法第六章分支限界法第七章随机化算法
1
算法设计与分析 >第一章目录
1.1 算法与程序 1.2 算法复杂度分析 1.3 NP完全性理论
2
算法设计与分析>算>法算概法述概述
1.1 算法与程序 1 算法定义及其特性
A
是
否
条件成立？
条件成立？
是
否
B
A
B
A
C
14
算法设计与分>析算>法算概法述概述
5. 算法分类
从解法上数值型算法:算法中的基本运算为算术运算. 非数值型算法:算法中的基本运算为逻辑运算.
从处理方式上串行算法:串行计算机上执行的算法. 并行算法:并行计算机上执行的算法.
本课程主要介绍非数值型的串行算法.
如果存在一个函数 ~T(n)使得当n ,有
(T(n) - ~T(n)) / T(n)0
称 ~T(n)是T(n)当 n 时的渐进性态或渐进复杂性
27
算法设计与分>>析算算法>法算复概法杂述概性分述析 >渐进性态
在数学上,T(n)与 ~T(有n)相同的最高阶项.可取为~T(略n去) T(n)的低阶项后剩余的主项. 例如 T(n)=3n2+4nlogn+7, 则 ~T(n) 可以是3n2 当n充分大时用 ~T(n)代替T(n)作为算法复杂性的度量, 以简化分析比较两个算法时，如果他们的阶不同，就可分出效率高低。故此时只需关心 ~T最(n高) 限的阶即可。可忽略最高项系数或低阶项。
4

厦门理工学院第二专业(计算机科学与技术专业)培养方案

附件3-9：
厦门理工学院第二专业（计算机科学与技术专业）培养方案
（2008级执行）
一、培养目标与培养规格
本专业培养适应海峡西岸经济区，尤其是厦门市经济与社会发展需要，具备科学素养，系统扎实地掌握计算机科学与技术特别是软件工程的基本理论、基本知识和基本技能与方法，符合计算机发展规律要求，能综合运用知识解决问题，具有社会责任感，具有一定的创新思维，能从事计算机软件设计、开发、应用和项目管理等工作的应用型高级专门人才。

二、毕业要求
1.辅修毕业要求：
符合学校相关规定，修满30学分，其中必须包含专业基础课19.5学分。

2.双专业毕业要求：
符合学校相关规定，修满57个学分，其中包括专业基础课19.5学分，专业课16学分，专业选修课15.5学分，专业教育实践训练6学分（不含毕业设计）。

3.双学位毕业要求：
符合学校相关规定，修满61个学分，其中包括专业基础课19.5学分，专业课16学分，专业选修课15.5学分，专业教育实践训练10学分。

三、主干学科和主要课程
主干学科：计算机科学与技术
主要课程：java程序设计、数据库原理与应用、计算机网络、操作系统、数据结构与算法、Web程序设计、软件工程导论、面向对象的系统分析与设计、设计模式、软件项目管理、软件测试技术、XML技术、J2EE架构与程序设计
四、主要实践性教学环节和专业实验
主要实践性教学环节：
java语言课程设计、计算机网络课程设计、数据结构与算法课程设计、Web
程序课程设计、
主要专业实践：
软件开发与测试、毕业论文
五、学制
学制：2年
（六）修读说明
（七）教学计划表与教学进程表。

厦门理工数据结构课程设计报告

《数据结构与算法》课程设计报告（2012— 2013学年第 1 学期）专业：网络工程班级：11网络工程姓名学号：1107022144指导教师：林仙丽成绩：计算机科学与技术系2013 年01 月11 日目录一．课程设计目的与要求 (1)1．设计目的 (1)2．设计任务及要求 (1)二 .方案实现与调试 (1)1．停车场管理系统 (1)1.1算法描述及实验步骤 (2)1.2调试过程及实验结果 (3)2．字符串操作 (4)2.1算法描述及实验步骤 (5)2.2调试过程及实验结果 (6)3．找祖先 (8)3.1算法描述及实验步骤 (9)3.2调试过程及实验结果 (10)4．二叉树运算2 (8)4.1算法描述及实验步骤 (9)4.2调试过程及实验结果 (1)三．课程设计分析与总结 (10)四．源程序清单 (11)1.停车场管理系统 (11)2．字符串操作 (19)3.找祖先 (22)4.二叉树运算2 (25)五．设计日志 (31)六．指导教师评语 (32)2一. 课程设计的目的与要求（含设计指标）1、设计目的（1）培养学生运用算法与数据结构的基本知识解决实际编程中的数据结构设计和算法设计问题。

（2）培养学生独立设计程序与解决问题的能力，培养学生团队协作集成程序模块及调试能力。

（3）培养学生初步的软件设计及软件测试的能力。

2、设计任务及要求基本要求：学生必须仔细阅读《数据结构》课程设计指导书，认真主动完成课程设计的要求。

有问题及时主动通过各种方式与教师联系沟通。

学生要发挥自主学习的能力，充分利用时间，安排好课设的时间计划，并在课设过程中不断检测自己的计划完成情况，及时的向教师汇报。

课程设计按照教学要求需要一周时间完成，一周中每天（按每周5天）至少要上3-4小时的机来调试C语言设计的程序，总共至少要上机调试程序15小时。

根据设计报告要求编写设计报告，主要内容包括目的、意义、原理和实现方法简介、过程分析及说明、实验结果情况说明、结论。

厦门理工c语言课程设计

厦门理工c语言课程设计一、课程目标知识目标：1. 理解C语言的基本语法和结构，掌握数据类型、变量、运算符的使用。

2. 学会使用C语言进行顺序、选择和循环结构的编程，并能运用逻辑思维解决问题。

3. 掌握函数的定义、调用和参数传递，理解模块化编程的思想。

4. 了解数组、字符串、指针在C语言中的应用，并能运用它们进行数据处理。

技能目标：1. 能够运用C语言编写简单的程序，解决实际问题。

2. 学会使用C语言调试工具，具备基本的程序调试能力。

3. 能够阅读和分析C语言代码，理解他人编写的程序逻辑。

4. 培养良好的编程习惯，编写规范、简洁、高效的代码。

情感态度价值观目标：1. 培养学生对编程的兴趣，激发学习主动性和创新精神。

2. 增强学生的逻辑思维能力，提高问题分析和解决能力。

3. 培养学生的团队协作意识，学会与他人共同解决问题。

4. 培养学生严谨、务实的科学态度，树立正确的价值观。

本课程针对厦门理工学院学生特点，结合C语言课程性质和教学要求，将目标分解为具体的学习成果。

课程旨在使学生掌握C语言的基本知识和技能，培养编程兴趣和逻辑思维能力，同时注重团队协作和科学态度的培养，为后续课程和实际应用打下坚实基础。

二、教学内容1. C语言基础知识：数据类型、变量、常量、运算符、表达式。

教材章节：第1章 C语言概述，第2章数据类型与运算符。

2. 控制结构：顺序结构、选择结构、循环结构。

教材章节：第3章控制语句。

3. 函数：函数定义、调用、参数传递、递归函数。

教材章节：第4章函数。

4. 数组与字符串：一维数组、二维数组、字符串操作。

教材章节：第5章数组与字符串。

5. 指针：指针的概念、指针与数组、指针与字符串、函数指针。

教材章节：第6章指针。

6. 结构体与联合体：结构体的定义、初始化、结构体数组、联合体。

教材章节：第7章结构体与联合体。

7. 文件操作：文件的概念、文件打开与关闭、文件读写、文件定位。

教材章节：第8章文件。

厦门理工c语言课课程设计

厦门理工c语言课课程设计一、教学目标本课程旨在通过C语言的学习，让学生掌握C语言的基本语法、数据类型、运算符、控制结构、函数等基本知识，培养学生编程思维和解决问题的能力。

同时，通过课程的学习，使学生了解编程在实际应用中的重要性，提高学生对计算机科学的兴趣和热情。

具体的教学目标如下：1.知识目标：(1)理解C语言的基本语法和编程规范；(2)掌握C语言的数据类型、运算符和表达式；(3)熟悉C语言的控制结构，如顺序结构、分支结构和循环结构；(4)了解函数的定义和调用，掌握函数的参数传递和返回值；(5)理解编程中常用的数据结构，如数组、链表、栈和队列等。

2.技能目标：(1)能够使用C语言编写简单的程序，解决实际问题；(2)具备基本的编程思维，能够独立分析和解决编程问题；(3)掌握C语言的调试技巧，能够有效地查找和修复程序错误。

3.情感态度价值观目标：(1)培养学生对编程的兴趣，提高学生对计算机科学的认识；(2)培养学生良好的编程习惯，提高学生的自律性和责任感；(3)培养学生团队合作精神，提高学生的沟通能力和协作能力。

二、教学内容本课程的教学内容主要包括C语言的基本语法、数据类型、运算符、控制结构、函数等基本知识。

具体安排如下：1.第一章：C语言概述介绍C语言的发展历程、特点和应用领域，使学生对C语言有一个整体的认识。

2.第二章：数据类型和运算符讲解C语言的基本数据类型、复杂数据类型和运算符，使学生能够熟练使用C语言进行数据操作。

3.第三章：控制结构介绍C语言的控制结构，包括顺序结构、分支结构和循环结构，使学生能够根据实际问题选择合适的控制结构。

4.第四章：函数讲解函数的定义、声明和调用，使学生能够理解函数的基本概念，并掌握函数的参数传递和返回值。

5.第五章：数组和字符串介绍数组和字符串的概念及其在C语言中的应用，使学生能够熟练使用数组和字符串解决实际问题。

6.第六章：指针讲解指针的概念和用法，使学生能够掌握指针在C语言中的应用，提高程序的性能。

matlab厦门理工课程设计

matlab厦门理工课程设计一、课程目标知识目标：1. 掌握MATLAB的基本操作和常用命令，了解其在工程计算中的应用；2. 学习MATLAB在数据可视化、矩阵运算、符号计算等方面的基本功能；3. 了解MATLAB编程的基本语法和编程技巧，培养良好的编程习惯。

技能目标：1. 能够运用MATLAB进行数据分析和处理，解决实际问题；2. 能够利用MATLAB编写简单的程序，实现算法和模型；3. 能够运用MATLAB进行图像处理、信号处理等领域的初步探索。

情感态度价值观目标：1. 培养学生对工程计算和MATLAB编程的兴趣，激发学生的学习热情；2. 培养学生的团队合作意识，提高学生解决问题的能力和沟通能力；3. 引导学生认识科技对社会发展的贡献，增强学生的社会责任感和创新意识。

课程性质：本课程为实践性较强的课程，旨在通过MATLAB软件的学习和应用，提高学生在工程计算领域的实际操作能力。

学生特点：学生具备一定的数学基础和编程兴趣，具有较强的学习能力和动手能力。

教学要求：注重理论与实践相结合，强调学生动手实践，鼓励学生探索和创新。

通过课程学习，使学生能够将MATLAB应用于实际工程计算中，提高解决实际问题的能力。

同时，关注学生的情感态度价值观培养，提高学生的综合素质。

二、教学内容1. MATLAB基础知识：介绍MATLAB软件的安装与配置，基本操作界面，常用命令和功能；教材章节：第一章MATLAB概述。

2. MATLAB编程基础：数据类型、矩阵运算、流程控制、函数编写等；教材章节：第二章MATLAB编程基础。

3. 数据可视化：二维、三维图形绘制，图像处理基本操作；教材章节：第三章数据可视化。

4. 符号计算：符号表达式计算，符号方程求解，符号矩阵运算；教材章节：第四章符号计算。

5. 算法实现与应用：数值分析算法、优化算法、信号处理等领域的应用；教材章节：第五章算法实现与应用。

6. MATLAB高级编程：面向对象编程、文件操作、GUI设计等；教材章节：第六章MATLAB高级编程。

算法设计与分析(精品课件)

xn个
n=4, m=7 可行解 <1, 2, 3, 1>
序列 1 0 1 1 0 1 1 1 0 1
13
蛮力算法的效率
序列个数是输入规模的指数函数
C(m n 1, m) (m n 1)!
m!(n 1)!
((1 )mn1 )
有没有更好的算法?
14
小结
问题求解的关键 • 建模：对输入参数和解给出形式化
本周教学内容
算法课程主要内容及有关概念 .
算法研究内容
算法的有关概念
计算复杂性理论：货郎问题背包问题
双机调度问题
问题复杂度概念：排序问题
算法设计与分析：调度问题投资问题
算几类重要函数的性质
法
的
有关函数渐近的界
伪
的定理
码
表示
时间复杂度函数的表示：函数渐近的界
算法及其时间复杂度的定义
2
• NP-hard问题的计算现状 • 计算复杂性理论的核心——NP完全
理论 • 算法研究的主要内容及重要意义
12
算法及其时间复杂度
1
问题及实例
• 问题
需要回答的一般性提问，通常含若干参数
• 问题描述
定义问题参数(集合,变量,函数,序列等) 说明每个参数的取值范围及参数间的关系定义问题的解说明解满足的条件(优化目标或约束条件)
或半形式化的描述
• 设计算法：采用什么算法设计技术正确性——是否对所有的实例都得到正确的解
• 分析算法——效率
15
问题计算复杂度的界定:排序问题
例3 排序算法的效率
以元素比较作基本运算
算法
最坏情况下

厦门理工_算法设计与分析_模拟试卷一

厦门理⼯_算法设计与分析_模拟试卷⼀1、对于下列各组函数f(n)和g(n)，确定f(n)=O(g(n))或或，并简述理由。

（12分）(1)(2)(3)解：简答如下：（1），（2），（3）2、试⽤分治法实现有重复元素的排列问题：设是要进⾏排列的个元素，其中元素可能相同，试计算的所有不同排列。

（13分）解：解答如下：Templatevoid Perm(Type list[],int k,int m){if(k= =m){for(int i=0;i<=m;i++) cout<SPAN ……………………………..<>（4分）cout<}else for(int i=k;i<=m;i++)if(ok(list,k,i)){swap(list[k],list[i]);Perm(list,k+1,m);swap(list[k],list[i]); ……………………………..（8分）};}其中ok⽤于判别重复元素。

Templateint ok(Type list[],int k,int i){if(i>k)if(list[t]= =list[i]) return 0;return 1;}……………………………..（13分）3、试⽤分治法对⼀个有序表实现⼆分搜索算法。

（12分）解：解答如下：Templateint BinarySearch(Type a[],const Type& x,int n){//假定数组a[]已按⾮递减有序排列，本算法找到x后返回其在数组a[]中的位置，//否则返回-1 int left=0,right=n-1;while(left<=right){int middle=(left+right)/2; ……………………………..（4分）if(x= =a[middle]) return middle+1;if(x>a[middle]) left=middle+1; ……………………………..（8分）else right=middle-1;}return -1;}……………………………..（12分）4、试⽤动态规划算法实现0-1背包问题。

算法设计与分析课程设计(完整版)

HUNAN CITY UNIVERSITY 算法设计与分析课程设计题目：求最大值与最小值问题专业：学号：姓名：指导教师：成绩：二0年月日一、问题描述输入一列整数，求出该列整数中的最大值与最小值。

二、课程设计目的通过课程设计，提高用计算机解决实际问题的能力，提高独立实践的能力，将课本上的理论知识和实际有机的结合起来，锻炼分析解决实际问题的能力。

提高适应实际，实践编程的能力。

在实际的编程和调试综合试题的基础上，把高级语言程序设计的思想、编程巧和解题思路进行总结与概括，通过比较系统地练习达到真正比较熟练地掌握计算机编程的基本功，为后续的学习打下基础。

了解一般程序设计的基本思路与方法。

三、问题分析看到这个题目我们最容易想到的算法是直接比较算法：将数组的第 1 个元素分别赋给两个临时变量：fmax:=A[1]; fmin:=A[1]; 然后从数组的第 2 个元素 A[2]开始直到第 n个元素逐个与 fmax 和 fmin 比较，在每次比较中，如果A[i] > fmax，则用 A[i]的值替换 fmax 的值；如果 A[i] < fmin，则用 A[i]的值替换 fmin 的值；否则保持 fmax（fmin）的值不变。

这样在程序结束时的fmax、fmin 的值就分别是数组的最大值和最小值。

这个算法在最好、最坏情况下，元素的比较次数都是 2(n-1)，而平均比较次数也为 2(n-1)。

如果将上面的比较过程修改为：从数组的第 2 个元素 A[2]开始直到第 n 个元素，每个 A[i]都是首先与 fmax 比较，如果 A[i]>fmax,则用 A[i]的值替换 fmax 的值；否则才将 A[i]与 fmin 比较，如果 A[i] < fmin，则用 A[i]的值替换 fmin 的值。

这样的算法在最好、最坏情况下使用的比较次数分别是 n-1 和 2(n-1),而平均比较次数是 3(n-1)/2,因为在比较过程中，将有一半的几率出现 A[i]>fmax 情况。

算法设计与分析智慧树知到课后章节答案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。

( )答案:对7.答案:8.从n个数中找出前k个最小的元素并对所选择的前k个最小的元素进行排序。