北航算法分析研究生课程3
《高等计算机算法-博士研究生》课程教学大纲

3.NP完全理论(6学时):NP完全理论及其在实际问题中的应用。
4.算法专题研究(10学时):3—5个小的前沿领域的算法专题研讨,包括每个领域的基本问题、算法及变型。
5.课程设计(2学时):设计并分析一个难度适当的算法。
2.3计算复杂性导论,堵丁柱、葛可一、王洁,高等教育出版社,2002
预修课程:离散数学,数据结构,算法分析
学科点意见:
学科点负责人签名:
年月日
注:1、类别指公共课、专业课。2、教学内容要强调理论性与应用性课程的有机结合,突出案例分析和实践研究;教学过程要重视运用团队学习、案例分析、现场研究、模拟训练等方法;要注重培养学生研究实践问题的意识和能力。3、编制者一般为该课程主讲教师。
研究生课程教学大纲
课程名称
中文
高等计算机算法
课程编号
0006100038
英文
AdvancedComputerAlgorithms
开课单位
网络空间先进技术研究院
考核方式
考查
学时
32
学分
2
类别
专业课
编制者
课程简介:
高级算法设计与分析是计算机科学与技术及相关专业一门重要的专业基础课。本课程是本科和硕士的算法课程的延续和提升。主要介绍算法的基本设计技巧及高级算法理论在前沿问题和实际问题中的应用。加深学生的算法研究能力,提高学生设计算法来解决实际问题的能力。
教学目标与基本要求:
本课程的目标是使学生通过对高等计算机算法基础的进阶学习以及前沿算法的专题研究,提升学生独立设计算法解决现实问题的能力。其基本要求为:
1.能够使用基本技巧设计算法。
2.理解NP完全理论,并能够应用于解决实际问题。
北航编译原理课件 03.词法分析

3. 词法分析程序算法
北京航空航天大学计算机学院
17
1.单词及内部表示 单词及内部表示: 单词及内部表示
单词名称
BEGIN END FOR DO IF THEN ELSE 标识符 常数(整 常数 整) : + * , ( ) :=
保留字和分界符采用一符一类
记忆符
BEGINSY ENDSY FORSY DOSY IFSY THENSY ELSESY IDSY INTSY COLONSY PLUSSY STARSY COMSY LPARSY RPARSY ASSIGNSY
字母、数字
标识符 无符号整数
单字符分界符
S S S
字母
标 数字
非字母数字
出口
数字
数
非数字
出口
+ * , 单界 ( ) :
其他字符 非=
出口
双字符分界符
北京航空航天大学计算机学院
S
冒号
=
双界
其他字符
出口 15
查保留字表 读字符
字母、数字
S
字母
标 数字
非字母数字
标识符
非数字
数字
数
无符号整数 单字符分界符
如:b{ab} = {ba}b {a|b} = {{a} {b}} = (a*b*)*
北京航空航天大学计算机学院 23
例:设 ∑ = { a,b },下面是定义在∑上的正则表达式和正则集合 正则表达式 ba* a(a|b)* (a|b)*(aa|bb)(a|b)* 正则集合
北京航空航天大学计算机学院
北京航空航天大学计算机学院 20
‘*’ : ‘,’ : ‘(’ : ‘)’ : ‘:’ :
北航数学分析考研真题

北航数学分析考研真题1. 章节一:简介北航(北京航空航天大学)数学分析考研真题是考研数学中重要的一部分。
通过对真题的分析和学习,考生可以更好地了解考试内容和要求,提高备考效果。
本文将对北航数学分析考研真题进行解析和讨论,以帮助考生有针对性地进行备考。
2. 章节二:题型及分析北航数学分析考研真题主要包括选择题、填空题和计算题。
选择题是考察考生对数学概念和理论的理解,要求准确把握概念,并能运用相关理论进行解答。
填空题则着重考察考生的运算和推理能力,要求灵活运用数学知识,进行简洁准确的计算和推导。
计算题则注重考察考生的计算和解题能力,要求熟练运用相关计算方法,正确解答问题。
3. 章节三:题目示例及解析以下是一道北航数学分析考研真题的示例,以便考生更好地理解题目类型和解题思路。
示例题目:已知函数f(x)可导,且f(2)=1,f'(2)=3,求$\lim\limits_{x\to2}\frac{f(x)-f(2)}{x-2}$。
解析:首先,根据已知条件可得到f(x)在x=2处的函数值和导数值。
根据导数的定义,我们可以将要求的极限化简为$\lim\limits_{x\to 2}f'(x)$。
由于f(x)可导,那么f(x)在x=2处必然连续,因此可以通过函数连续性的性质得到$\lim\limits_{x\to 2}f(x)=f(2)=1$。
所以最终要求的极限等于f(x)在x=2处的导数值,即极限为3。
通过以上解析可以看出,北航数学分析考研真题注重考察考生对基本概念和理论的掌握,以及运算和推理能力的应用。
考生在备考过程中,需要注重对知识点的理解和灵活运用,通过大量的练习和实践来巩固和提高解题能力。
4. 章节四:备考建议为了更好地备考北航数学分析考研真题,考生可以采取以下几点建议:4.1 深入理解概念和理论:对于每个知识点,要从概念入手,深入理解其含义和应用场景。
掌握基本定义和推导过程,能够准确运用相关理论进行解答。
北航数值分析全部三次大作业

北航数值分析全部三次大作业第一次大作业是关于解线性方程组的数值方法。
我们被要求实现各种常用的线性方程组求解算法,例如高斯消元法、LU分解法和迭代法等。
我首先学习了这些算法的原理和实现方法,并借助Python编程语言编写了这些算法的代码。
在实验中,我们使用了不同规模和条件的线性方程组进行测试,并比较了不同算法的性能和精度。
通过这个作业,我深入了解了线性方程组求解的原理和方法,提高了我的编程和数值计算能力。
第二次大作业是关于数值积分的方法。
数值积分是数值分析中的重要内容,它可以用于计算曲线的长度、函数的面积以及求解微分方程等问题。
在这个作业中,我们需要实现不同的数值积分算法,例如矩形法、梯形法和辛普森法等。
我学习了这些算法的原理和实现方法,并使用Python编写了它们的代码。
在实验中,我们计算了不同函数的积分值,并对比了不同算法的精度和效率。
通过这个作业,我深入了解了数值积分的原理和方法,提高了我的编程和数学建模能力。
第三次大作业是关于常微分方程的数值解法。
常微分方程是数值分析中的核心内容之一,它可以用于描述众多物理、化学和生物现象。
在这个作业中,我们需要实现不同的常微分方程求解算法,例如欧拉法、龙格-库塔法和Adams法等。
我学习了这些算法的原理和实现方法,并使用Python编写了它们的代码。
在实验中,我们解决了一些具体的常微分方程问题,并比较了不同算法的精度和效率。
通过这个作业,我深入了解了常微分方程的原理和方法,提高了我的编程和问题求解能力。
总的来说,北航数值分析课程的三次大作业非常有挑战性,但也非常有意义。
通过这些作业,我在数值计算和编程方面得到了很大的提升,也更加深入地了解了数值分析的理论和方法。
虽然这些作业需要大量的时间和精力,但我相信这些努力将会对我未来的学习和工作产生积极的影响。
北航有限元分析与应用第三讲 ppt课件.ppt

Nj 0
0 Nj
Nm 0
0 Nm
u v
j j
简写为
N e INi
IN j
INm
i j
um
vm
ui
m
e
i j
m
vi
u v
j j
um
vm
[I]是单位矩阵,
[N]称为形函数矩阵,
Ni只与单元节点坐标有关,称为 单元的形状函数
3-2 平面问题的常应变(三角形)单元
坐标轴的平行移动而改变。
3-3 单元刚度矩阵
Fe [B]T[D][B]tdxdyδe
由于[D]中元素是常量,而在线性位移模式下,[B]中的
元素也是常量,且 dxdy A
因此
Fe [B]T[D][B]tA δe
Ke [B]T[D][B]tA
可以进一步得出平面应力问题和平面应变问题中的单元 刚度矩阵。
Fyj*
j
Fxj*
F ym m
y t
xy
F yi
x
F xi
i
F xm
(a)结点力、内部应力
Fym* m
x* y* xy*
F
* xm
(b)虚位移、虚应变
Fyi*
F
* xi
i
3-3 单元刚度矩阵
考虑上图三角形单元的实际受力,节点力和内部应力为:
Fxi
Fyi
F
Fxj Fyj
Fxm
Fym
u v
j j
um
vm
ui
1 2A
b0i ci
0 ci bi
bj 0 cj
0 cj bj
bm 0 cm
计算机学院-北航研究生院-北京航空航天大学

计算机学院计算机科学与技术(0812)博士研究生培养方案一、适用学科计算机科学与技术(0812)二、培养目标1.坚持党的基本路线,热爱祖国,遵纪守法,品行端正,诚实守信,身心健康,具有良好的科研道德和敬业精神。
2.在计算机科学与技术方面具有坚实宽广的理论基础和系统深入的专门知识,全面了解学科发展动向;具有独立从事科学研究的能力;具有良好的综合素质;能够独立地、创造性地从事科学研究工作,或具有主持较大型科研、技术开发项目,或解决经济、社会发展问题的能力;至少能熟练运用一门外国语撰写科技论文和进行国际学术交流。
3.在科学或专门技术上做出创造性的成果。
三、培养方向按计算机科学与技术一级学科统一招生,按计算机系统结构、计算机软件与理论、计算机应用技术、计算机网络与信息安全等培养博士研究生。
学科培养方向包括:1.计算机系统结构:具体研究方向包括高性能计算机体系结构、嵌入式与容错计算技术、网络体系结构、分布式计算机系统、计算机存储技术、并行计算技术、分布式计算技术、新概念计算技术等;2.计算机软件与理论:具体研究方向计算复杂性理论、计算系统建模理论、算法理论、智能计算理论、程序的形式化理论与编程模型、程序变换方法与技术、新型程序设计方法、可计算性理论、海量信息的理论与方法、软件中间件技术等;3.计算机应用技术:具体研究方向数据库应用技术、多媒体技术、数字图像及音视频处理、虚拟现实技术与系统、计算机视觉、模式识别、计算机仿真技术、嵌入式系统应用、物联网应用、云计算应用、服务计算、社会计算、大规模计算机应用工程化等;4.计算机网络与信息安全:具体研究方向计算机网络理论、网络传输技术、网络管理技术、网络计算技术、计算机网络应用技术、计算机安全技术、软件安全技术、网络安全技术、信息对抗技术、内容安全技术、行为安全技术、信息隐藏与检测以及可信计算技术等。
四、培养模式及学习年限本学科博士研究生主要按一级学科培养,鼓励开展国际联合培养,实行导师或联合导师负责制,负责制订研究生个人培养计划、指导科学研究和学位论文。
北航研究生数值分析大作业三
数值分析—计算实习作业三学院:17系专业:精密仪器及机械姓名:张大军学号:DY1417114一、程序设计方案程序设计方案流程图如图1所示。
(注:由本人独立完成,并且有几处算法很巧妙,但同时也有许多不足,可以优化和模块化,由于时间原因只实现了调试通过)图1.程序设计方案流程图二、程序源代码#include <iostream.h>#include <iomanip.h>#include <math.h>#include<stdio.h>#include <conio.h>#define M 10000#define N 4#define E 1.0e-12int zuixiaci;static double c[9][9];static double bijin[8][5];int main(){double X[N]={0,0,0,1};double T[11][21],U[11][21],xianshi[11][21];double diertX[N];double F[N];double f[N][N];double Max1=0,Max2=0;int k,i,j,t,tt=0,yao=0;void qiuF(double * X,double *F,int i,int j);void qiuF2(double *X,double *F,int i,int j);void qiuf(double * X,double (*f)[N]);void qiudiertX(double (*a)[N],double*b,double*X); double gouzaohs(double t,double u); void solve_C(double (*U)[21]); void pp(double (*U)[21],int k);for(i=0;i<11;i++)for(j=0;j<21;j++){for(k=0;k<M;k++){qiuF(X,F,i,j);qiuf(X,f);qiudiertX(f,F,diertX);for(t=0;t<N;t++){X[t]=X[t]+diertX[t];}Max1=0,Max2=0;for(t=0;t<N;t++){if(Max1<fabs(X[t]))Max1=fabs(X[t]);if(Max2<fabs(diertX[t]))Max2=fabs(diertX[t]);}if((Max2/Max1)<=E){k=M;yao=1;T[i][j]=X[0];U[i][j]=X[1];xianshi[i][j]=gouzaohs(X[0],X[1]);cout<<setiosflags(ios::scientific)<<setprecision(12);cout<<setprecision(2)<<"("<<setw(5)<<0.08*i<<","<<setw(5)<< (0.5+0.05*j)<<",";cout<<setprecision(12)<<setw(21)<<xianshi[i][j]<<") ";if(tt==3){tt=0;cout<<'\n';cout<<'\n';}else{tt++;}}}if(yao==0)cout<<"迭代不成功"<<endl; yao=0;}cout<<endl;solve_C(xianshi);pp(xianshi,zuixiaci);tt=0;for(i=1;i<9;i++)for(j=1;j<6;j++){for(k=0;k<M;k++){qiuF2(X,F,i,j);qiuf(X,f);qiudiertX(f,F,diertX);for(t=0;t<N;t++){X[t]=X[t]+diertX[t];}Max1=0,Max2=0;for(t=0;t<N;t++){if(Max1<fabs(X[t]))Max1=fabs(X[t]);if(Max2<fabs(diertX[t]))Max2=fabs(diertX[t]);}if((Max2/Max1)<=E){k=M;yao=1;xianshi[i-1][j-1]=gouzaohs(X[0],X[1]);cout<<setiosflags(ios::scientific)<<setprecision(12);cout<<setprecision(2)<<"("<<setw(5)<<0.1*i<<","<<setw(5)<<( 0.5+0.2*j)<<",";cout<<setprecision(12)<<setw(21)<<xianshi[i-1][j-1]<<","<<set w(21)<<bijin[i-1][j-1]<<") ";if(tt==2){tt=0;cout<<'\n';}else{tt++;}}}if(yao==0)cout<<"迭代不成功"<<endl;yao=0;}cout<<endl;return 1;}void qiuF(double *X,double *F,int i,int j){F[0]=-(0.5*cos(X[0])+X[1]+X[2]+X[3]-0.08*i-2.67);F[1]=-(X[0]+0.5*sin(X[1])+X[2]+X[3]-(0.5+0.05*j)-1.07);F[2]=-(0.5*X[0]+X[1]+cos(X[2])+X[3]-0.08*i-3.74);F[3]=-(X[0]+0.5*X[1]+X[2]+sin(X[3])-(0.5+0.05*j)-0.79); }void qiuF2(double *X,double *F,int i,int j){F[0]=-(0.5*cos(X[0])+X[1]+X[2]+X[3]-0.1*i-2.67);F[1]=-(X[0]+0.5*sin(X[1])+X[2]+X[3]-(0.5+0.2*j)-1.07);F[2]=-(0.5*X[0]+X[1]+cos(X[2])+X[3]-0.1*i-3.74);F[3]=-(X[0]+0.5*X[1]+X[2]+sin(X[3])-(0.5+0.2*j)-0.79); }void qiuf(double *X,double (*f)[N]){f[0][0]=-0.5*sin(X[0]);f[0][1]=1;f[0][2]=1;f[0][3]=1;f[1][0]=1;f[1][1]=0.5*cos(X[1]);f[1][2]=1;f[1][3]=1;f[2][0]=0.5;f[2][1]=1;f[2][2]=-sin(X[2]);f[2][3]=1;f[3][0]=1;f[3][1]=0.5;f[3][2]=1;f[3][3]=cos(X[3]);}//求解关于变化X的线性方程组void qiudiertX(double (*a)[N],double*b,double*X) {double H[N][N]={0},l[N]={0};double B;double sum;int i,j,m,k,z;for(k=0;k<N-1;k++){for(j=k;j<N;j++){l[j]=a[k][j];}z=k;for(m=k;m<N;m++){if(fabs(a[z][k])<fabs(a[m][k]))z=m;}for(j=k;j<N;j++){a[k][j]=a[z][j];a[z][j]=l[j];}B=b[k];b[k]=b[z];b[z]=B;for(i=k+1;i<N;i++){H[i][k]=a[i][k]/a[k][k];for(j=k+1;j<N;j++)a[i][j]=a[i][j]-H[i][k]*a[k][j];b[i]=b[i]-H[i][k]*b[k];}}if(a[N-1][N-1]==0){cout<<"算法失效,停止计算"<<endl; }else{X[N-1]=b[N-1]/a[N-1][N-1];for(k=N-2;k>=0;k--){sum=0;for(j=k+1;j<N;j++){sum=sum+a[k][j]*X[j];}X[k]=(b[k]-sum)/a[k][k];}}}//作二元差值,使用分片二次代数插值double gouzaohs(double t,double u){double T[6]={0,0.2,0.4,0.6,0.8,1},U[6]={0,0.4,0.8,1.2,1.6,2};double Z[6][6]={-0.5,-0.34,0.14,0.94,2.06,3.5,-0.42,-0.5,-0.26,0.3,1.18,2.38,-0.18,-0.5,-0.5,-0.18,0.46,1.42,0.22,-0.34,-0.58,-0.5,-0.1,0.62,0.78,-0.02,-0.5,-0.66,-0.5,-0.02,1.5,0.46,-0.26,-0.66,-0.74,-0.5};double g=0,sum=0,sum1=1,sum2=1;int i=0,j=0,k=0,r=0,kk=0,rr=0;for(i=1;(i<6)&&(T[i]-0.1<t);i++){}for(j=1;(j<6)&&(U[j]-0.2<u);j++){}if(i==1)i=2;if(i==6)i=5;if(j==1)j=2;if(j==6)j=5;sum=0;for(k=i-2;k<i+1;k++)for(r=j-2;r<j+1;r++){sum1=1;sum2=1;for(kk=i-2;kk<i+1;kk++){if(k!=kk){sum1=sum1*(t-T[kk])/(T[k]-T[kk]);}}for(rr=j-2;rr<j+1;rr++){if(r!=rr){sum2=sum2*(u-U[rr])/(U[r]-U[rr]);}}sum=sum+sum1*sum2*Z[k][r];}g=sum;return g;}//求r*s阶矩阵A与s*t阶矩阵B的乘积矩阵Cvoid Multi(double *a, double *b, double *c, int la, int lb, int lc, int r, int s, int t){int i, j, k;for (i=0; i<r; i++)for (j=0; j<t; j++){*(c+i*lc+j)=0;for (k=0; k<s; k++)*(c+i*lc+j)+=*(a+i*la+k)*(*(b+k*lb+j));}}//求n阶方阵A的逆矩阵Bdouble Inverse(double *a, double *b, int la, int lb, int n){int i, j, k;double temp;for(i=0; i<n; i++)for(j=0; j<n; j++)if (i==j)*(b+i*lb+j)=1;else*(b+i*lb+j)=0;for (k=0; k<n; k++){j=k;for (i=k+1; i<n; i++)if (fabs(*(a+i*la+k))>fabs(*(a+j*la+k))) j=i;if (j!=k)for (i=0; i<n; i++){temp=*(a+j*la+i);*(a+j*la+i)=*(a+k*la+i);*(a+k*la+i)=temp;temp=*(b+j*lb+i);*(b+j*lb+i)=*(b+k*lb+i);*(b+k*lb+i)=temp;}if (*(a+k*la+k)==0)return 0;if ((temp=*(a+k*la+k))!=1)for (i=0; i<n; i++){*(a+k*la+i)/=temp;*(b+k*lb+i)/=temp;}for (i=0; i<n; i++)if ((*(a+i*la+k)!=0) && (i!=k)){temp=*(a+i*la+k);for (j=0; j<n; j++){*(a+i*la+j)-=temp*(*(a+k*la+j));*(b+i*lb+j)-=temp*(*(b+k*lb+j));}}}return 0;}void solve_C(double (*U)[21]){int i,j,r,s,k;double t1[21][21], t2[21][21], t3[21][21],d[9][9],e[9][9];double B[11][9], B_T[9][11], G[21][9], G_T[9][21],P[11][21];double temp, FangCha;for(i=0;i<9;i++){for(j=0;j<11;j++){B[j][i]=pow(0.08*j,i);B_T[i][j]=pow(0.08*j,i);}for(j=0;j<21;j++){G[j][i]=pow(0.5+0.05*j,i);G_T[i][j]=pow(0.5+0.05*j,i);}}for (k=0; k<9; k++){FangCha=0;Multi(B_T[0], B[0], t1[0], 11, 9, 21, k+1, 11, k+1);Inverse(t1[0], c[0], 21, 9, k+1);Multi(e[0], c[0], d[0], 9, 9, 9, k+1, k+1, k+1);Multi(c[0], B_T[0], t1[0], 9, 11, 21, k+1, k+1, 11);Multi(t1[0], U[0], t2[0], 21, 21, 21, k+1, 11, 21);Multi(G_T[0], G[0], t1[0], 21, 9, 21, k+1, 21, k+1);Inverse(t1[0], c[0], 21, 9, k+1);Multi(G[0], c[0], t3[0], 9, 9, 21, 21, k+1, k+1);Multi(t2[0], t3[0], c[0], 21, 21, 9, k+1, 21, k+1);for(i=0;i<11;i++)for(j=0;j<21;j++){temp=0;for(r=0;r<k+1;r++)for(s=0;s<k+1;s++)temp+=c[r][s]*B[i][r]*G[j][s];P[i][j]=temp;FangCha+=(U[i][j]-temp)*(U[i][j]-temp);}cout<<"k="<<setw(5)<<k<<";"<<setw(5)<<"Sigma="<<FangCha<<" ;\n"<<'\n';if(FangCha<=1.0e-7){zuixiaci=k;cout<<"达到精度要求时: k="<<setw(5)<<k<<";"<<setw(5)<<"Sigma="<<FangCha<<";\n";cout<<" 系数c(r,s)如下:\n";for(i=0;i<k+1;i++){for(j=0;j<k+1;j++){cout<<"C("<<i<<","<<j<<")="<<setw(21)<<c[i][j]<<"; ";}cout<<endl<<'\n';}cout<<endl;return;}}cout<<"经过8次拟合没有达到所需精度;"<<endl;//最高可拟合10次return;}void pp(double (*U)[21],int k){int i,j,r,s;double B[8][9],G[5][9],temp;for(i=0;i<k+1;i++){for(j=0;j<8;j++){B[j][i]=pow(0.1*(j+1),i);}for(j=0;j<5;j++){G[j][i]=pow(0.5+0.2*(j+1),i);}}for(i=0;i<8;i++)for(j=0;j<5;j++){temp=0;for(r=0;r<k+1;r++)for(s=0;s<k+1;s++)temp+=c[r][s]*B[i][r]*G[j][s];bijin[i][j]=temp;}}三、程序运行结果显示程序运行结果显示如图2。
北航数值分析-lec7-幂法和反幂法
迭代收敛性
反幂法在求解特征值问题中的应用
特征值问题
反幂法主要用于求解矩阵的特征值和特征向量问题。通过迭代过程,反幂法能够找到矩阵的所有特征 值和对应的特征向量。
数值稳定性
反幂法在求解特征值问题时,需要关注数值稳定性问题。由于计算机浮点运算的误差累积,反幂法可 能会产生数值不稳定的解。因此,需要采取适当的策略来提高数值稳定性。
误差分析比较
幂法
由于幂法是通过连续的矩阵乘法来计算矩阵的幂,因此误差会随着计算的次数逐渐 累积。为了减小误差,需要选择合适的计算精度和减少计算次数。
反幂法
反幂法是通过求解线性方程组来计算矩阵的逆和行列式,因此误差主要来自于线性 方程组的求解精度。为了减小误差,需要选择合适的求解方法和提高求解精度。
202X
北航数值分析-lec7-幂法 和反幂法
单击此处添加副标题内容
汇报人姓名 汇报日期
目 录幂法介绍Fra bibliotek反幂法介绍
幂法和反幂法的比较
幂法和反幂法的实现细节
幂法和反幂法的实际应用案例
单击此处输入你的正文,文字是
您思想的提炼,请尽量言简意赅
的阐述观点
contents
单击此处输入你的正文,文字是 您思想的提炼,请尽量言简意赅 的阐述观点
反幂法的实现细节
反幂法是一种迭代算法,用 于求解线性方程组的近似逆。
反幂法的收敛速度取决于矩阵的谱 半径,如果矩阵的谱半径较小,则 反幂法收敛速度较快。
ABCD
反幂法的实现步骤包括:选择初始 矩阵、计算迭代矩阵、更新解矩阵 和判断收敛性。
在实际应用中,反幂法通常用于 求解大规模稀疏线性系统的预处 理和后处理问题。
01
北京航空航天大学研究生2011秋季课程表
星期四
《数值分析B-3班》1周-15周1节-2节 主M102 001+004+009+010+013+015 《数值分析A-2班》1周-15周3节-4节 主349 《马克思主义理论(硕)-5班》1周-16周5节-6节 主M101 006+020+026 《马克思主义理论(硕)-6班》1周-16周7节-8节 主M101 007+008 《马克思主义理论(硕)-7班》1周-16周5节-6节 主M401 012+013+015 《马克思主义理论(硕)-8班》1周-16周7节-8节 主M401 009+017+019+DFJ 星期五 《数理统计B-3班》1周-15周1节-2节 主M102 007+010+013+015+017+027 《人文专题课:科学思想史》1周-7周5节-8节 主M102 《数理统计B-2班》1周-15周3节-4节 主M101 002+004+005+006 《数理统计B-1班》1周-15周1节-2节 主M101 001+003 《数理统计A》1周-15周3节-4节 主M102 《数值分析B-4班》1周-15周3节-4节 主M102 002+005 《数值分析B-2班》1周-15周3节-4节 主M101 003 星期六 《数值分析A-1班》1周-15周1节-2节 主349 《数值分析B-1班》1周-15周1节-2节 主M101 007+008+014 《数值分析B-3班》1周-15周1节-2节 主M102 001+004+009+010+013+015 《数值分析A-2班》1周-15周3节-4节 主349
(完整word版)北航研究生算法设计与分析Assignment_2
用分支定界算法求以下问题:某公司于乙城市的销售点急需一批成品,该公司成品生产基地在甲城市。
甲城市与乙城市之间共有n 座城市,互相以公路连通。
甲城市、乙城市以及其它各城市之间的公路连通情况及每段公路的长度由矩阵M1 给出。
每段公路均由地方政府收取不同额度的养路费等费用,具体数额由矩阵M2 给出。
请给出在需付养路费总额不超过1500 的情况下,该公司货车运送其产品从甲城市到乙城市的最短运送路线。
具体数据参见文件:m1.txt: 各城市之间的公路连通情况及每段公路的长度矩阵(有向图); 甲城市为城市Num.1,乙城市为城市Num.50。
m2.txt: 每段公路收取的费用矩阵(非对称)。
思想:利用Floyd算法的基本方法求解。
程序实现流程说明:1.将m1.txt和m2.txt的数据读入两个50×50的数组。
2.用Floyd算法求出所有点对之间的最短路径长度和最小费用。
3.建立一个堆栈,初始化该堆栈。
4.取出栈顶的结点,检查它的相邻的所有结点,确定下一个当前最优路径上的结点,被扩展的结点依次加入堆栈中。
在检查的过程中,如果发现超出最短路径长度或者最小费用,则进行”剪枝”,然后回溯。
5.找到一个解后,保存改解,然后重复步骤4。
6.重复步骤4、5,直到堆栈为空,当前保存的解即为最优解。
时间复杂度分析:Floyd算法的时间复杂度为3O N,N为所有城市的个数。
()该算法的时间复杂度等于DFS的时间复杂度,即O(N+E)。
其中,E为所有城市构成的有向连通图的边的总数。
但是因为采用了剪枝,会使实际运行情况的比较次数远小于E。
求解结果:算法所得结果:甲乙之间最短路线长度是:464最短路线收取的费用是:1448最短路径是:1 3 8 11 15 21 23 26 32 37 39 45 47 50C源代码(注意把m1.txt与m2.txt放到与源代码相同的目录下,下面代码可直接复制运行):#include<stdlib.h>#include<stdio.h>#include<time.h>#include<string.h>#define N 50#define MAX 52void input(int a[N][N],int b[N][N]);void Floyd(int d[N][N]);void fenzhi(int m1[N][N],int m2[N][N],int mindist[N][N],int mincost[N][N]);int visited[N],bestPath[N];void main(){clock_t start,finish;double duration;int i,j,mindist[N][N],mincost[N][N],m1[N][N],m2[N][N]; /* m1[N][N]和m2[N][N]分别代表题目所给的距离矩阵和代价矩阵*/// int visited[N],bestPath[N];FILE *fp,*fw;// system("cls");time_t ttime;time(&ttime);printf("%s",ctime(&ttime));start=clock();for(i=0;i<N;i++){visited[i]=0;bestPath[i]=0;}fp=fopen("m1.txt","r"); /* 把文件中的距离矩阵m1读入数组mindist[N][N] */if(fp==NULL){printf("can not open file\n");return;}for(i=0;i<N;i++)for(j=0;j<N;j++)fscanf(fp,"%d",&mindist[i][j]);fclose(fp); /* 距离矩阵m1读入完毕*/fp=fopen("m2.txt","r"); /* 把文件中的代价矩阵m2读入数组mincost[N][N] */if(fp==NULL){printf("can not open file\n");return;}for(i=0;i<N;i++)for(j=0;j<N;j++)fscanf(fp,"%d",&mincost[i][j]);fclose(fp); /* 代价矩阵m2读入完毕*/input(m1,mindist); /* mindist[N][N]赋值给m1[N][N],m1[N][N]代表题目中的距离矩阵*/input(m2,mincost); /* mincost[N][N]赋值给m2[N][N],m2[N][N]代表题目中的代价矩阵*/for(i=0;i<N;i++) /* 把矩阵mindist[i][i]和mincost[i][i]的对角元素分别初始化,表明城市到自身不连通,代价为0 */{mindist[i][i]=9999;mincost[i][i]=0;}Floyd(mindist); /* 用弗洛伊德算法求任意两城市之间的最短距离,结果存储在数组mindist[N][N]中*//*fw=fopen("1.txt","w");for(i=0;i<N;i++){for(j=0;j<N;j++)fprintf(fw,"%4d ",mindist[i][j]);fprintf(fw,"\n");}fclose(fw);// getchar();//*/Floyd(mincost); /* 用弗洛伊德算法求任意两城市之间的最小代价,结果存储在数组mincost[N][N]中*//*fw=fopen("2.txt","w");for(i=0;i<N;i++){for(j=0;j<N;j++)fprintf(fw,"%4d ",mincost[i][j]);fprintf(fw,"\n");}fclose(fw);// getchar();//*/fenzhi(m1,m2,mindist,mincost); /* 调用分支定界的实现函数,寻找出所有的可行路径并依次输出*/finish=clock();duration = (double)(finish - start) / CLOCKS_PER_SEC;printf( "%f seconds\n", duration );//*/}void Floyd(int d[N][N]) /* 弗洛伊德算法的实现函数*/{int v,w,u,i;for(u=0;u<N;u++){for(v=0;v<N;v++){for(w=0;w<N;w++)if(d[v][u]+d[u][w]<d[v][w]){//printf("v,w,u,d[v][u],d[u][w],d[v][w] %d %d %d %d %d %d",v+1,w+1,u+1,d[v][u],d[u][w],d[v][ w]);getchar();d[v][w]=d[v][u]+d[u][w];}}}}void input(int a[N][N],int b[N][N]) /* 把矩阵b赋值给矩阵a */{int i,j;for(i=0;i<N;i++)for(j=0;j<N;j++)a[i][j]=b[i][j];}void fenzhi(int m1[N][N],int m2[N][N],int mindist[N][N],int mincost[N][N]){int stack[MAX],depth=0,next,i,j; /* 定义栈,depth表示栈顶指针;next指向每次遍历时当前所处城市的上一个已经遍历的城市*/int bestLength,shortestDist,minimumCost,distBound=9999,costBound=9999;int cur,currentDist=0,currentCost=0; /* cur指向当前所处城市,currentDist和currentCost分别表示从甲城市到当前所处城市的最短距离和最小代价,currentDist和currentCost初值为0表示从甲城市出发开始深度优先搜索*/stack[depth]=0; /* 对栈进行初始化*/stack[depth+1]=0;visited[0]=1; /* visited[0]=1用来标识从甲城市开始出发进行遍历,甲城市已被访问*/while(depth>=0) /* 表示遍历开始和结束条件,开始时从甲城市出发,栈空,depth=0;结束时遍历完毕,所有节点均被出栈,故栈也为空,depth=0 *//* 整个while()循环体用来实现从当前的城市中寻找一个邻近的城市*/{cur=stack[depth]; /* 取栈顶节点赋值给cur,表示当前访问到第cur号城市*/ next=stack[depth+1]; /* next指向当前所处城市的上一个已经遍历的城市*/for(i=next+1;i<N;i++) /* 试探当前所处城市的每一个相邻城市*/{if((currentCost+mincost[cur][N-1]>costBound)||(currentDist+mindist[cur][N-1]>=distBound)){ /* 所试探的城市满足剪枝条件,进行剪枝*///printf("here1 %d %d %d %d %d %d %d\n",cur,currentCost,mincost[cur][49],costBound,curre ntDist,mindist[cur][49],distBound); getchar();//printf("%d %d %d %d %d %d",cur,i,m1[cur][i],currentCost,mincost[cur][49],costBound); getchar();continue;}if(m1[cur][i]==9999) continue; /* 所试探的城市不连通*/if(visited[i]==1) continue; /* 所试探的城市已被访问*/if(i<N) break; /* 所试探的城市满足访问条件,找到新的可行城市,终止for循环*/ }if(i==N) /* 判断for循环是否是由于搜索完所有城市而终止的,如果是(i==N),进行回溯*/{// printf("here");getchar();depth--;currentDist-=m1[stack[depth]][stack[depth+1]];currentCost-=m2[stack[depth]][stack[depth+1]];visited[stack[depth+1]]=0;}else /* i!=N,表示for循环的终止是由于寻找到了当前城市的一个可行的邻近城市*/{//printf("%d %d %d %d %d %d\n",cur,i,m1[stack[depth]][i],m2[stack[depth]][i],currentCost,curre ntDist);//getchar();currentDist+=m1[stack[depth]][i]; /* 把从当前所处城市到所找到的可行城市的距离加入currentDist */currentCost+=m2[stack[depth]][i]; /* 把从当前所处城市到所找到的可行城市的代价加入currentCost */depth++; /* 所找到的可行城市进栈*/stack[depth]=i; /* 更新栈顶指针,指向所找到的可行城市*/stack[depth+1]=0;visited[i]=1; /* 修改所找到的城市的访问标志*/if(i==N-1) /* i==N-1表示访问到了乙城市,完成了所有城市的一次搜索,找到一条通路*/{// printf("here\n");for(j=0;j<=depth;j++) /* 保存当前找到的通路所经过的所有节点*/ bestPath[j]=stack[j];bestLength=depth; /* 保存当前找到的通路所经过的所有节点的节点数*/shortestDist=currentDist; /* 保存当前找到的通路的距离之和*/minimumCost=currentCost; /* 保存当前找到的通路的代价之和*///costBound=currentCost;distBound=currentDist; /* 更新剪枝的路径边界,如果以后所找到的通路路径之和大于目前通路的路径之和,就剪枝*/if(minimumCost>1500) continue; /* 如果当前找到的通路的代价之和大于1500,则放弃这条通路*/printf("最短路径:%3d,路径代价:%3d,所经历的节点数目:%3d,所经历的节点如下:\n",shortestDist,minimumCost,bestLength+1); /* 输出找到的通路的结果*/bestPath[bestLength]=49;for(i=0;i<=bestLength;i++) /* 输出所找到的通路所经过的具体的节点*/ printf("%3d ",bestPath[i]+1);(完整word版)北航研究生算法设计与分析Assignment_2 printf("\n");depth--; /* 连续弹出栈顶的两个值,进行回溯,开始寻找新的可行的通路*/currentDist-=m1[stack[depth]][stack[depth+1]];currentCost-=m2[stack[depth]][stack[depth+1]];visited[stack[depth+1]]=0;depth--;currentDist-=m1[stack[depth]][stack[depth+1]];currentCost-=m2[stack[depth]][stack[depth+1]];visited[stack[depth+1]]=0;// getchar();}}}}。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
A Proposed Technique
A more efficient implementation of step 2 is obtained by: • keeping only a list of un-chosen vertices:
– UNCHSN (I), which initially contains NUMUN = N – 1 vertices,
Step 0.
Step 1.
Step 2.
Step 3.
[Initialize] Set T ← a network consisting of N vertices and no edges; set H ← G. [Iterate] While T is not a connected network do through step 3 od; STOP. [Pick a lightest edge] Let (U,V) be a lightest (cheapest) edge in H; if T + (U,V) has no cycles then [add (U,V) to T] set T ← T + (U,V) fi. [Delete (U, V) from H] Set H ← H – (U, V).
Complete Development of an Algo.
• • • • • • • • 1 Statement of the problem 2 Development of a Model 3 Design of the algorithm 4 Correctness of the algorithm 5 Implementation 6 Analysis and complexity of the algorithm 7 Program testing 8 Documentation
Analysis of Algorithm C
• Correctness • Time complexity
– A rough analysis----O(N2) – A detailed analysis
• Simplicity • Optimality
Flow Chart of Algorithm C
Last SectionFra bibliotekn Example
• • • • • • • • Task Problem analyzing Statement of the problem Development of a Model Design of the algorithm Correctness of the algorithm Implementation Analysis and complexity of the algorithm
step 2的一个效率更高的实现:
• 保存 未选择节点的一个列表:
– UNCHSN (I), 初始包括 NUMUN = M – 1 个节 点,
• 创建两个额外的数组:
– LIGHT(I), 等于ith 未选择节点 和已选节点之间 的最轻的边的费用值 – VERTEX(I), 该条边上的已选择节点
• 用这些数组,算法 B 的step 2 可按如下实现 (1) 在数组 LIGHT里搜索最轻的边, 比如, LIGHT(K); (2) 从UNCHSN 列表里删除第k个元素。 (通过把 最后一个未选择节点UNCHSN(NUMUN) 放到 UNCHSN(K) 来实现); (3) NUMUN= NUMUN-1; (4) 记录新选择的 LIGHT 边; 且 (5) 用原来的 UNCHSN(K) 作为新选择的节点, 通 过比较 LIGHT(I) 和 C(l, UNCHSN(K)),更新剩 下的未选择节点的值.
• creating two additional arrays:
– LIGHT(I), which equals the value of the lightest edge between the ith unchosen vertex and a chosen vertex, and – VERTEX(I), which contains the chosen vertex on this edge.
Flow Chart of Algorithm C
1. Start 2. Initialization 3. Update lightest edge from each unchosen vertex to a chosen vertex 4. Pick a lightest edge e from an unchosen vertex to a chosen vertex 5. Add edge e to MST 6. Delete newly chosen vertex from unchosen list 7. IF No unchosen vertices left THEN Stop 8. GOTO 3
• Algorithm B
To find a minimum-weight spanning tree T in a weighted, connected network G with N vertices and M edges.
[Initialize] Label all vertices ―unchosen‖; set T ← a network with N vertices and no edges; choose an arbitrary vertex and label it ―chosen‖. Step 1. [Iterate] While there is an unchosen vertex do step 2 od; STOP. Step 2. [Pick a lightest edge] Let (U, V) be a lightest edge between any chosen vertex U and any unchosen vertex V; label V as ―chosen‖; and set T ← T + (U, V). Step 0.
Does it work?
• There are several questions we should ask about this algorithm;
1. Does it always STOP? 2. When it STOPs, is T always a spanning tree of G? 3. Is T guaranteed to be a minimum-weight spanning tree? 4. Is it self-contained (or does it contain hidden, or implicit, sub-algorithms)? 5. Is it efficient?
w(T )
( u ,v )T
w(u, v)
is minimized
• Algorithm A To find a minimum-weight spanning tree T in a weighted, connected network G with N vertices and M edges.
Question 4&5
• Step 1 requires a sub-algorithm to determine if a network is connected, and • step 2 requires a sub-algorithm to decide if a network has a cycle. • These two steps can make the algorithm ineffective in that these sub-algorithms might be time-consuming.
Complete Development of an Algo.
• • • • • • • • 1 Statement of the problem 2 Development of a Model 3 Design of the algorithm 4 Correctness of the algorithm 5 Implementation 6 Analysis and complexity of the algorithm 7 Program testing 8 Documentation
Does it work?
• There are several questions we should ask about this algorithm;
1. Does it always STOP? 2. When it STOPs, is T always a spanning tree of G? 3. Is T guaranteed to be a minimum-weight spanning tree? 4. Is it self-contained (or does it contain hidden, or implicit, sub-algorithms)? 5. Is it efficient?
1. Start 2. Initialization 3. Update lightest edge from each unchosen vertex to a chosen vertex(a single vertex) 4. Pick a lightest edge e from an unchosen vertex to a chosen vertex 5. Add edge e to MST 6. Delete newly chosen vertex from unchosen list 7. IF No unchosen vertices left THEN Stop 8. GOTO 3