数学建模十大算法部分带有源代码

合集下载

数学建模中常用的十种算法

数学建模中常用的十种算法在数学建模中，有许多种算法可以用来解决不同类型的问题。

下面列举了数学建模中常用的十种算法。

1.线性规划算法：线性规划是一种优化问题，目标是找到一组线性约束条件下使目标函数最大或最小的变量的值。

常用的线性规划算法包括单纯形法、内点法和对偶法等。

2.非线性规划算法：非线性规划是一种目标函数或约束条件中存在非线性项的优化问题。

常见的非线性规划算法有牛顿法、拟牛顿法和遗传算法等。

3.整数规划算法：整数规划是一种线性规划的扩展，约束条件中的变量必须为整数。

常用的整数规划算法包括分支定界法、割平面法和混合整数线性规划法等。

4.动态规划算法：动态规划是一种通过将问题分解为更小的子问题来解决的算法。

它适用于一类有重叠子问题和最优子结构性质的问题，例如背包问题和最短路径问题。

5.聚类算法：聚类是一种将数据集划分为不同群组的算法。

常见的聚类算法有K均值算法、层次聚类法和DBSCAN算法等。

6.回归分析算法：回归分析是一种通过拟合一个数学模型来预测变量之间关系的算法。

常见的回归分析算法有线性回归、多项式回归和岭回归等。

7.插值算法：插值是一种通过已知数据点推断未知数据点的数值的算法。

常用的插值算法包括线性插值、拉格朗日插值和样条插值等。

8.数值优化算法：数值优化是一种通过改变自变量的取值来最小化或最大化一个目标函数的算法。

常见的数值优化算法有梯度下降法、共轭梯度法和模拟退火算法等。

9.随机模拟算法：随机模拟是一种使用概率分布来模拟和模拟潜在结果的算法。

常见的随机模拟算法包括蒙特卡洛方法和离散事件仿真等。

10.图论算法：图论是一种研究图和网络结构的数学理论。

常见的图论算法有最短路径算法、最小生成树算法和最大流量算法等。

以上是数学建模中常用的十种算法。

这些算法的选择取决于问题的特性和求解的要求，使用合适的算法可以更有效地解决数学建模问题。

数学建模十大算法部分带有源代码综述

数学建模竞赛中应当掌握的十类算法
• • •ห้องสมุดไป่ตู้• • • • • • •
蒙特卡罗算法数据处理算法数学规划算法图论算法动态规划、回溯搜索、分治算法、分支定界三大非经典算法网格算法和穷举法连续离散化方法数值分析算法图象处理算法
1、蒙特卡罗算法
该算法又称随机性模拟算法，是通过计算机仿真来解决问题的算法，同时可以通过模拟可以来检验自己模型的正确性，是比赛时必用的方法
现在假设需要识别出这一伪币。把两个或三个硬币的情况作为不可再分的小问题。注意如果只有一个硬币，那么不能判断出它是否就是伪币。在一个小问题中，通过将一个硬币分别与其他两个硬币比较，最多比较两次就可以找到伪币。这样，1 6硬币的问题就被分为两个8硬币（A组和B组）的问题。通过比较这两组硬币的重量，可以判断伪币是否存在。如果没有伪币，则算法终止。否则，继续划分这两组硬币来寻找伪币。假设B是轻的那一组，因此再把它分成两组，每组有4 个硬币。称其中一组为B1，另一组为B2。比较这两组，肯定有一组轻一些。如果B1轻，则伪币在B1中，再将B1又分成两组，每组有两个硬币，称其中一组为B1a，另一组为B1b。比较这两组，可以得到一个较轻的组。由于这个组只有两个硬币，因此不必再细分。比较组中两个硬币的重量，可以立即知道哪一个硬币轻一些。较轻的硬币就是所要找的伪币。
例2-1 [找出伪币] 给你一个装有1 6个硬币的袋子。1 6个硬币中有一个是伪造的，并且那个伪造的硬币比真的硬币要轻一些。你的任务是找出这个伪造的硬币。为了帮助你完成这一任务，将提供一台可用来比较两组硬币重量的仪器，利用这台仪器，可以知道两组硬币的重量是否相同。
比较硬币1与硬币2的重量。假如硬币1比硬币 2轻，则硬币1是伪造的；假如硬币2比硬币1 轻，则硬币2是伪造的。这样就完成了任务。假如两硬币重量相等，则比较硬币3和硬币4。同样，假如有一个硬币轻一些，则寻找伪币的任务完成。假如两硬币重量相等，则继续比较硬币5和硬币6。按照这种方式，可以最多通过8次比较来判断伪币的存在并找出这一伪币。

数学建模十大经典算法

法解及题试模建学数国全年历
。理处行进 baltaM 用使常通�题问的决解要需是就理处何如及以示展何如形
。 1 � y � x 是件条要充的内形扇在落 P。值似近的 k 为作 n/m 比的 n 数总的点投所与 m 数点的内形扇在落将。内形扇在落点个少多有中其看等相会机的置位个一每中形方正在落点的投所使�点多很入投机随中形方正在是法办个一�呢 K 例比的占中积面形方正在积面形扇出求样怎。值的 iP 到得而从�1S 到得能即立就 S/1S=K 例比的占中 S 积面形方正在 1S 积面形扇出求能要只。分部一的形方正位单 1 为长边是它�形扇个一是积面 4/1 的圆位单。iP 到得而从 4/iP 得求来积面的 4/1 的圆位单求用利�中法分积值数在 �等线行平括包�题例的似相多很有�例实法算、2 。解似近的题问得获以�样抽或拟模计统现实机算计用�系联相型模率概的定一同题问的解求所将是它�法方的题问算计多很决解来�数机随伪的见常更或�数机随用使指是�法方拟模计统称也。法方算计种一的础基为法方论理计统和率概以解理的义含、1
�点特的展发题赛
论图
B01 A01 划规态动排安理合的床病科眼 B90 析分法方制控的台验试器动制 A90 讨探准标费学育教等高 B80 位定机相码数 A80 理处据数划规标目多运奥看�交公乘 B70 测预长增口人国中 A70 测预的效疗及价评的法疗病滋艾 B60 置配源资版出 A60
393141.3 051931.3 002531.3 000580.3 000011.3
测预和价评的质水江长 A50 计设点网市超时临会运奥 A40 排安辆车的产生矿天露 B30 播传的 SRAS A30 题问票彩 B20 理管塞阻电输的场市力电 B40
赁租线在 DVD B50

数学建模应该掌握的十大算法(汇编)

数学建模竞赛中应当掌握的十类算法排名如下：1、蒙特卡罗算法（该算法又称随机性模拟算法，是通过计算机仿真来解决问题的算法，同时可以通过模拟可以来检验自己模型的正确性，是比赛时必用的方法）2、数据拟合、参数估计、插值等数据处理算法（比赛中通常会遇到大量的数据需要处理，而处理数据的关键就在于这些算法，通常使用Matlab作为工具）3、线性规划、整数规划、多元规划、二次规划等规划类问题（建模竞赛大多数问题属于最优化问题，很多时候这些问题可以用数学规划算法来描述，通常使用Lindo、Lingo软件实现）4、图论算法（这类算法可以分为很多种，包括最短路、网络流、二分图等算法，涉及到图论的问题可以用这些方法解决，需要认真准备）5、动态规划、回溯搜索、分治算法、分支定界等计算机算法（这些算法是算法设计中比较常用的方法，很多场合可以用到竞赛中）6、最优化理论的三大非经典算法：模拟退火法、神经网络、遗传算法（这些问题是用来解决一些较困难的最优化问题的算法，对于有些问题非常有帮助，但是算法的实现比较困难，需慎重使用）7、网格算法和穷举法（网格算法和穷举法都是暴力搜索最优点的算法，在很多竞赛题中有应用，当重点讨论模型本身而轻视算法的时候，可以使用这种暴力方案，最好使用一些高级语言作为编程工具）8、一些连续离散化方法（很多问题都是实际来的，数据可以是连续的，而计算机只认的是离散的数据，因此将其离散化后进行差分代替微分、求和代替积分等思想是非常重要的）9、数值分析算法（如果在比赛中采用高级语言进行编程的话，那一些数值分析中常用的算法比如方程组求解、矩阵运算、函数积分等算法就需要额外编写库函数进行调用）10、图象处理算法（赛题中有一类问题与图形有关，即使与图形无关，论文中也应该要不乏图片的，这些图形如何展示以及如何处理就是需要解决的问题，通常使用Matlab进行处理）8.1 遗传算法的概念是建立在自然选择和自然遗传学机理基础上的迭代自适应概率性搜索算法，在1975年由Holland教授提出。

10个重要的算法C语言实现源代码

/*///////////////////////////////////*/ 10个重要的算法C语言实现源代码： // 拉格朗日， // 牛顿插值， // 高斯， // 龙贝格， // 牛顿迭代， // 牛顿-科特斯， // 雅克比， // 秦九昭， // 幂法， // 高斯塞德尔 /*///1.拉格朗日插值多项式，用于离散数据的拟合//C/C++ code#include <stdio.h>#include <conio.h>#include <alloc.h>float lagrange(float *x,float *y,float xx,int n) /*拉格朗日插值算法*/{int i,j;float *a,yy=0.0; /*a作为临时变量，记录拉格朗日插值多项式*/a=(float *)malloc(n*sizeof(float));for(i=0;i<=n-1;i++){a[i]=y[i];for(j=0;j<=n-1;j++)if(j!=i) a[i]*=(xx-x[j])/(x[i]-x[j]);yy+=a[i];}free(a);return yy;}main(){int i,n;float x[20],y[20],xx,yy;printf("Input n:");scanf("%d",&n);if(n>=20){printf("Error!The value of n must in (0,20)."); getch();return 1;}if(n<=0){printf("Error! The value of n must in (0,20)."); getch();return 1;}for(i=0;i<=n-1;i++){printf("x[%d]:",i);scanf("%f",&x[i]);}printf("\n");for(i=0;i<=n-1;i++){printf("y[%d]:",i);scanf("%f",&y[i]);}printf("\n");printf("Input xx:");scanf("%f",&xx);yy=lagrange(x,y,xx,n);printf("x=%f,y=%f\n",xx,yy);getch();}//2.牛顿插值多项式，用于离散数据的拟合//C/C++ code#include <stdio.h>#include <conio.h>#include <alloc.h>void difference(float *x,float *y,int n){float *f;int k,i;f=(float *)malloc(n*sizeof(float));for(k=1;k<=n;k++){ f[0]=y[k];for(i=0;i<k;i++)f[i+1]=(f[i]-y[i])/(x[k]-x[i]);y[k]=f[k];}return;}main(){int i,n;float x[20],y[20],xx,yy;printf("Input n:");scanf("%d",&n);if(n>=20){printf("Error! The value of n must in (0,20)."); getch();return 1;}if(n<=0){printf("Error! The value of n must in (0,20)."); getch();return 1;}for(i=0;i<=n-1;i++){printf("x[%d]:",i);scanf("%f",&x[i]);}printf("\n");for(i=0;i<=n-1;i++){printf("y[%d]:",i);scanf("%f",&y[i]);}printf("\n");difference(x,(float *)y,n);printf("Input xx:");scanf("%f",&xx);yy=y[20];for(i=n-1;i>=0;i--) yy=yy*(xx-x[i])+y[i];printf("NewtonInter(%f)=%f",xx,yy);getch();}//3.高斯列主元消去法,求解其次线性方程组//C/C++ code#include<stdio.h>#include <math.h>#define N 20int main(){int n,i,j,k;int mi,tmp,mx;float a[N][N],b[N],x[N];printf("\nInput n:");scanf("%d",&n);if(n>N){ printf("The input n should in(0,N)!\n"); getch();return 1;}if(n<=0){ printf("The input n should in(0,N)!\n"); getch();return 1;}printf("Now input a(i,j),i,j=0...%d:\n",n-1); for(i=0;i<n;i++){for(j=0;j<n;j++)scanf("%f",&a[i][j]);}printf("Now input b(i),i,j=0...%d:\n",n-1); for(i=0;i<n;i++)scanf("%f",&b[i]);for(i=0;i<n-2;i++){for(j=i+1,mi=i,mx=fabs(a[i][j]);j<n-1;j++) if(fabs(a[j][i])>mx){mi=j;mx=fabs(a[j][i]);}if(i<mi){tmp=b[i];b[i]=b[mi];b[mi]=tmp;for(j=i;j<n;j++){tmp=a[i][j];a[i][j]=a[mi][j];a[mi][j]=tmp;}}for(j=i+1;j<n;j++){tmp=-a[j][i]/a[i][i];b[j]+=b[i]*tmp;for(k=i;k<n;k++)a[j][k]+=a[i][k]*tmp;}}x[n-1]=b[n-1]/a[n-1][n-1];for(i=n-2;i>=0;i--){x[i]=b[i];for(j=i+1;j<n;j++)x[i]-=a[i][j]*x[j];x[i]/=a[i][i];}for(i=0;i<n;i++)printf("Answer:\n x[%d]=%f\n",i,x[i]); getch();return 0;}#include<math.h>#include<stdio.h>#define NUMBER 20#define Esc 0x1b#define Enter 0x0dfloat A[NUMBER][NUMBER+1] ,ark;int flag,n;exchange(int r,int k);float max(int k);message();main()float x[NUMBER];int r,k,i,j;char celect;clrscr();printf("\n\nUse Gauss.");printf("\n\n1.Jie please press Enter.");printf("\n\n2.Exit press Esc.");celect=getch();if(celect==Esc)exit(0);printf("\n\n input n=");scanf("%d",&n);printf(" \n\nInput matrix A and B:");for(i=1;i<=n;i++){printf("\n\nInput a%d1--a%d%d and b%d:",i,i,n,i); for(j=1;j<=n+1;j++)scanf("%f",&A[i][j]);}for(k=1;k<=n-1;k++){ark=max(k);if(ark==0){printf("\n\nIt's wrong!");message();}else if(flag!=k)exchange(flag,k);for(i=k+1;i<=n;i++)for(j=k+1;j<=n+1;j++)A[i][j]=A[i][j]-A[k][j]*A[i][k]/A[k][k];}x[n]=A[n][n+1]/A[n][n];for( k=n-1;k>=1;k--){float me=0;for(j=k+1;j<=n;j++){me=me+A[k][j]*x[j];}x[k]=(A[k][n+1]-me)/A[k][k];}for(i=1;i<=n;i++)printf(" \n\nx%d=%f",i,x[i]);}message();}exchange(int r,int k){int i;for(i=1;i<=n+1;i++)A[0][i]=A[r][i];for(i=1;i<=n+1;i++)A[r][i]=A[k][i];for(i=1;i<=n+1;i++)A[k][i]=A[0][i];}float max(int k){int i;float temp=0;for(i=k;i<=n;i++)if(fabs(A[i][k])>temp){temp=fabs(A[i][k]);flag=i;}return temp;}message() {printf("\n\n Go on Enter ,Exit press Esc!"); switch(getch()){case Enter: main();case Esc: exit(0);default:{printf("\n\nInput error!");message();}}//4.龙贝格求积公式，求解定积分//C/C++ code#include<stdio.h>#include<math.h>#define f(x) (sin(x)/x)#define N 20#define MAX 20#define a 2#define b 4#define e 0.00001float LBG(float p,float q,int n){int i;float sum=0,h=(q-p)/n;for (i=1;i<n;i++)sum+=f(p+i*h);sum+=(f(p)+f(q))/2;return(h*sum);}void main(){int i;int n=N,m=0;float T[MAX+1][2];T[0][1]=LBG(a,b,n);n*=2;for(m=1;m<MAX;m++){for(i=0;i<m;i++)T[i][0]=T[i][1];T[0][1]=LBG(a,b,n);n*=2;for(i=1;i<=m;i++)T[i][1]=T[i-1][1]+(T[i-1][1]-T[i-1][0])/(pow(2,2*m)-1); if((T[m-1][1]<T[m][1]+e)&&(T[m-1][1]>T[m][1]-e)){printf("Answer=%f\n",T[m][1]); getch();return ;}}//5.牛顿迭代公式，求方程的近似解//C/C++ code#include<stdio.h>#include<math.h>#include<conio.h>#define N 100#define PS 1e-5#define TA 1e-5float Newton(float (*f)(float),float(*f1)(float),float x0 ) {float x1,d=0;int k=0;do{x1= x0-f(x0)/f1(x0);if((k++>N)||(fabs(f1(x1))<PS)){printf("\nFailed!");getch();exit();}d=(fabs(x1)<1?x1-x0:(x1-x0)/x1);x0=x1;printf("x(%d)=%f\n",k,x0);}while((fabs(d))>PS&&fabs(f(x1))>TA) ;return x1;}float f(float x){return x*x*x+x*x-3*x-3;}float f1(float x){return 3.0*x*x+2*x-3;}void main(){float f(float);float f1(float);float x0,y0;printf("Input x0: ");scanf("%f",&x0);printf("x(0)=%f\n",x0);y0=Newton(f,f1,x0);printf("\nThe root is x=%f\n",y0);getch();}//6. 牛顿-科特斯求积公式，求定积分//C/C++ code#include<stdio.h>#include<math.h>float (*a)[];float h;int n,f;float *r;int NC(a,h,n,r,f){int nn,i;float ds;if(n>1000||n<2){if (f)printf("\n Faild! Check if 1<n<1000!\n",n);return(-1);}if(n==2){*r=0.5*((*a)[0]+(*a)[1])*(h);return(0);}if (n-4==0){*r=0;*r=*r+0.375*(h)*((*a)[n-4]+3*(*a)[n-3]+3*(*a)[n-2]+(*a)[n-1]); return(0);}if(n/2-(n-1)/2<=0)nn=n;elsenn=n-3;ds=(*a)[0]-(*a)[nn-1];for(i=2;i<=nn;i=i+2)ds=ds+4*(*a)[i-1]+2*(*a)[i];*r=ds*(h)/3;if(n>nn)*r=*r+0.375*(h)*((*a)[n-4]+3*(*a)[n-3]+3*(*a)[n-2]+(*a)[n-1]); return(0);}main(){float h,r;int n,ntf,f;int i;float a[16];printf("Input the x[i](16):\n");for(i=0;i<=15;i++)scanf("%d",&a[i]);h=0.2;f=0;ntf=NC(a,h,n,&r,f);if(ntf==0)printf("\nR=%f\n",r);elseprintf("\n Wrong!Return code=%d\n",ntf);getch();}//7.雅克比迭代，求解方程近似解//C/C++ code#include <stdio.h>#include <math.h>#define N 20#define MAX 100#define e 0.00001int main(){int n;int i,j,k;float t;float a[N][N],b[N][N],c[N],g[N],x[N],h[N];printf("\nInput dim of n:"); scanf("%d",&n);if(n>N){printf("Faild! Check if 0<n<N!\n"); getch(); return 1; } if(n<=0){printf("Faild! Check if 0<n<N!\n");getch();return 1;}printf("Input a[i,j],i,j=0…%d:\n",n-1);for(i=0;i<n;i++)for(j=0;j<n;j++)scanf("%f",&a[i][j]);printf("Input c[i],i=0…%d:\n",n-1);for(i=0;i<n;i++)scanf("%f",&c[i]);for(i=0;i<n;i++)for(j=0;j<n;j++){b[i][j]=-a[i][j]/a[i][i]; g[i]=c[i]/a[i][i]; }for(i=0;i<MAX;i++){for(j=0;j<n;j++)h[j]=g[j];{for(k=0;k<n;k++){if(j==k)continue;h[j]+=b[j][k]*x[k];}}t=0;for(j=0;j<n;j++)if(t<fabs(h[j]-x[j])) t=fabs(h[j]-x[j]);for(j=0;j<n;j++)x[j]=h[j];if(t<e){printf("x_i=\n");for(i=0;i<n;i++)printf("x[%d]=%f\n",i,x[i]);getch();return 0;}printf("after %d repeat , return\n",MAX);getch();return 1;}getch();}//8.秦九昭算法//C/C++ code#include <math.h>float qin(float a[],int n,float x) {float r=0;int i;for(i=n;i>=0;i--)r=r*x+a[i];return r;}main(){float a[50],x,r=0;int n,i;do{printf("Input frequency:");scanf("%d",&n);}while(n<1);printf("Input value:");for(i=0;i<=n;i++)scanf("%f",&a[i]);printf("Input frequency:");scanf("%f",&x);r=qin(a,n,x);printf("Answer:%f",r);getch();}//9.幂法//C/C++ code#include<stdio.h>#include<math.h>#define e 0.00001#define n 3float x[n]={0,0,1};float a[n][n]={{2,3,2},{10,3,4},{3,6,1}}; float y[n];main(){int i,j,k;float xm,oxm;oxm=0;for(k=0;k<N;k++){for(j=0;j<n;j++){y[j]=0;for(i=0;i<n;i++)y[j]+=a[j][i]*x[i];}xm=0;for(j=0;j<n;j++)if(fabs(y[j])>xm) xm=fabs(y[j]);for(j=0;j<n;j++)y[j]/=xm;for(j=0;j<n;j++)x[j]=y[j];if(fabs(xm-oxm)<e){printf("max:%f\n\n",xm);printf("v[i]:\n");for(k=0;k<n;k++)printf("%f\n",y[k]);break;}oxm=xm;}getch();}//10.高斯塞德尔//C/C++ code#include<math.h>#include<stdio.h>#define M 99float a[N][N];float b[N];int main(){int i,j,k,n;float sum,no,d,s,x[N];printf("\nInput dim of n:");scanf("%d",&n);if(n>N){printf("Faild! Check if 0<n<N!\n "); getch();return 1;}if(n<=0){printf("Faild! Check if 0<n<N!\n "); getch();return 1;}printf("Input a[i,j],i,j=0…%d:\n",n-1); for(i=0;i<n;i++)for(j=0;j<n;j++)scanf("%f",&a[i][j]);printf("Input b[i],i=0…%d:\n",n-1); for(i=0;i<n;i++)scanf("%f",&b[i]);for(i=0;i<n;i++) x[i]=0;k=0;printf("\nk=%dx=",k);for(i=0;i<n;i++)printf("%12.8f",x[i]);do{k++;if(k>M){printf("\nError!\n");getch();}break;}no=0.0;for(i=0;i<n;i++){s=x[i];sum=0.0;for(j=0;j<n;j++)if (j!=i)sum=sum+a[i][j]*x[j];x[i]=(b[i]-sum)/a[i][i];d=fabs(x[i]-s);if (no<d)no=d;}printf("\nk=%2dx=",k);for(i=0;i<n;i++)printf("%f",x[i]);}while (no>=0.1e-6);if(no<0.1e-6){printf("\n\n answer=\n");printf("\nk=%d",k);for (i=0;i<n;i++)printf("\n x[%d]=%12.8f",i,x[i]); }getch();}。

数学建模常用的十大算法

数学建模常用的十大算法一、线性回归算法线性回归算法（linear regression）是数学建模中最常用的算法之一，用于研究变量之间的线性关系。

它可以将变量之间的关系建模为一个线性方程，从而找出其中的关键因素，并预测未来的变化趋势。

二、逻辑回归算法逻辑回归算法（logistic regression）是一种用于建立分类模型的线性回归算法。

它可用于分类任务，如肿瘤疾病的预测和信用评级的决定。

逻辑回归利用某个事件的概率来建立分类模型，这个概率是通过一个特定的函数来计算的。

三、决策树算法决策树算法（decision tree）是一种非参数化的分类算法，可用于解决复杂的分类和预测问题。

它使用树状结构来描述不同的决策路径，每个分支表示一个决策，而每个叶子节点表示一个分类结果。

决策树算法的可解释性好，易于理解和解释。

四、k-均值聚类算法k-均值聚类算法（k-means clustering）是无监督学习中最常用的算法之一，可用于将数据集分成若干个簇。

此算法通过迭代过程来不断优化簇的质心，从而找到最佳的簇分类。

k-均值聚类算法简单易用，但对于高维数据集和离群值敏感。

五、支持向量机算法支持向量机算法（support vector machine）是一种强大的分类和回归算法，可用于解决复杂的非线性问题。

该算法基于最大化数据集之间的间隔，找到一个最佳的超平面来将数据分类。

支持向量机算法对于大型数据集的处理效率较高。

六、朴素贝叶斯算法朴素贝叶斯算法（naive bayes）是一种基于贝叶斯定理的分类算法，用于确定不同变量之间的概率关系。

该算法通过使用先验概率来计算各个变量之间的概率，从而预测未来的变化趋势。

朴素贝叶斯算法的处理速度快且适用于高维数据集。

七、随机森林算法随机森林算法（random forest）是一种基于决策树的分类算法，它利用多个决策树来生成随机森林，从而提高预测的准确性。

该算法通过随机化特征选择和子决策树的训练，防止过度拟合，并产生更稳定的预测结果。

数学建模算法的matlab代码

二，hamiton回路算法提供一种求解最优哈密尔顿的算法---三边交换调整法，要求在运行jiaohuan3（三交换法）之前，给定邻接矩阵C和节点个数N，结果路径存放于R中。

bianquan.m文件给出了一个参数实例，可在命令窗口中输入bianquan,得到邻接矩阵C和节点个数N以及一个任意给出的路径R,，回车后再输入jiaohuan3,得到了最优解。

由于没有经过大量的实验，又是近似算法，对于网络比较复杂的情况，可以尝试多运行几次jiaohuan3,看是否能到进一步的优化结果。

%%%%%%bianquan.m%%%%%%%N=13;for i=1:Nfor j=1:NC(i,j)=inf;endendfor i=1:NC(i,i)=0;endC(1,2)=6.0;C(1,13)=12.9;C(2,3)=5.9;C(2,4)=10.3;C(3,4)=12.2;C(3,5)=17.6;C(4,13)=8.8;C(4,7)=7.4;C(4,5)=11.5;C(5,2)=17.6;C(5,6)=8.2;C(6,9)=14.9;C(6,7)=20.3;C(7,9)=19.0;C(7,8)=7.3;C(8,9)=8.1;C(8,13)=9.2;C(9,10)=10.3;C(10,11)=7.7;C(11,12)=7.2;C(12,13)=7.9;for i=1:Nfor j=1:Nif C(i,j) < infC(j,i)=C(i,j);endendendfor i=1:NC(i,i)=0;endR=[4 7 6 5 3 2 1 13 12 11 10 9 8];<pre name="code" class="plain">%%%%%%%%jiaohuan3.m%%%%%%%%%%n=0;for I=1:(N-2)for J=(I+1):(N-1)for K=(J+1):Nn=n+1;Z(n,:)=[I J K];endendendR=1:Nfor m=1:(N*(N-1)*(N-2)/6)I=Z(m,1);J=Z(m,2);K=Z(m,3); r=R;if J-I~=1&K-J~=1&K-I~=N-1 for q=1:(J-I)r(I+q)=R(J+1-q);endfor q=1:(K-J)r(J+q)=R(K+1-q);endendif J-I==1&K-J==1r(K)=R(J);r(J)=R(K);endif J-I==1&K-J~=1&K-I~=N-1 for q=1:(K-J)r(I+q)=R(I+1+q); endr(K)=R(J);endif K-J==1&J-I~=1&K~=Nfor q=1:(J-I)r(I+1+q)=R(I+q); endr(I+1)=R(K);endif I==1&J==2&K==Nfor q=1:(N-2)r(1+q)=R(2+q);endr(N)=R(2);endif I==1&J==(N-1)&K==Nfor q=1:(N-2)r(q)=R(1+q);endr(N-1)=R(1);endif J-I~=1&K-I==N-1for q=1:(J-1)r(q)=R(1+q);endr(J)=R(1);endif J==(N-1)&K==N&J-I~=1r(J+1)=R(N);for q=1:(N-J-1)r(J+1+q)=R(J+q);endendif cost_sum(r,C,N)<cost_sum(R,C,N)R=rendendfprintf('总长为%f\n',cost_sum(R,C,N))%%%%%%cost_sum.m%%%%%%%%functiony=cost_sum(x,C,N)y=0;for i=1:(N-1)y=y+C(x(i),x(i+1));endy=y+C(x(N),x(1));三，灰色预测代码<pre name="code" class="plain">clearclcX=[136 143 165 152 165 181 204 272 319 491 571 605 665 640 628];x1(1)=X(1);X1=[];for i=1:1:14x1(i+1)=x1(i)+X(i+1);X1=[X1,x1(i)];endX1=[X1,X1(14)+X(15)]for k=3:1:15p(k)=X(k)/X1(k-1);p1(k)=X1(k)/X1(k-1);endp,p1clear kZ=[];for k=2:1:15z(k)=0.5*X1(k)+0.5*X1(k-1);Z=[Z,z(k)];endZB=[-Z',ones(14,1)]Y=[];clear ifor i=2:1:15Y=[Y;X(i)];endYA=inv(B'*B)*B'*Yclear ky1=[];for k=1:1:15y(k)=(X(1)-A(2)/A(1))*exp(-A(1)*(k-1))+A(2)/A(1); y1=[y1;y(k)];endy1clear kX2=[];for k=2:1:15x2(k)=y1(k)-y1(k-1);X2=[X2;x2(k)];endX2=[y1(1);X2]e=X'-X2m=abs(e)./X's=e'*en=sum(m)/13clear ksyms ky=(X(1)-A(2)/A(1))*exp(-A(1)*(k-1))+A(2)/A(1)Y1=[];for j=16:1:21y11=subs(y,k,j)-subs(y,k,j-1);Y1=[Y1;y11];endY1%程序中的变量定义:alpha是包含α、μ值的矩阵;%ago是预测后累加值矩阵;var是预测值矩阵;%error是残差矩阵; c是后验差比值function basicgrey(x,m) %定义函数basicgray(x)if nargin==1 %m为想预测数据的个数，默认为1 m=1;endclc; %清屏,以使计算结果独立显示if length(x(:,1))==1 %对输入矩阵进行判断,如不是一维列矩阵,进行转置变换x=x';endn=length(x); %取输入数据的样本量x1(:,1)=cumsum(x); %计算累加值,并将值赋及矩阵be for i=2:n %对原始数列平行移位 Y(i-1,:)=x(i,:);endfor i=2:n %计算数据矩阵B的第一列数据z(i,1)=0.5*x1(i-1,:)+0.5*x1(i,:);endB=ones(n-1,2); %构造数据矩阵BB(:,1)=-z(2:n,1);alpha=inv(B'*B)*B'*Y; %计算参数α、μ矩阵for i=1:n+m %计算数据估计值的累加数列,如改n+1为n+m可预测后m个值ago(i,:)=(x1(1,:)-alpha(2,:)/alpha(1,:))*exp(-alpha(1, :)*(i-1))+alpha(2,:)/alpha(1,:);endvar(1,:)=ago(1,:);f or i=1:n+m-1 %可预测后m个值var(i+1,:)=ago(i+1,:)-ago(i,:); %估计值的累加数列的还原,并计算出下m个预测值end[P,c,error]=lcheck(x,var); %进行后验差检验[rela]=relations([x';var(1:n)']); %关联度检验ago %显示输出预测值的累加数列alpha %显示输出参数α、μ数列var %显示输出预测值error %显示输出误差P %显示计算小残差概率 c %显示后验差的比值crela %显示关联度judge(P,c,rela) %评价函数显示这个模型是否合格<pre name="code" class="plain">function judge(P,c,rela) %评价指标并显示比较结果if rela>0.6'根据经验关联度检验结果为满意（关联度只是参考主要看后验差的结果）'else'根据经验关联度检验结果为不满意（关联度只是参考主要看后验差的结果）'endif P>0.95&c<0.5'后验差结果显示这个模型评价为“优”'else if P>0.8&c<0.5'后验差结果显示这个模型评价为“合格”'else if P>0.7&c<0.65'后验差结果显示这个模型评价为“勉强合格”' else'后验差结果显示这个模型评价为“不合格”' endendendfunction [P,c,error]=lcheck(x,var)%进行后验差检验n=length(x);for i=1:nerror(i,:)=abs(var(i,:)-x(i,:)); %计算绝对残差c=std(abs(error))/std(x); %调用统计工具箱的标准差函数计算后验差的比值cs0=0.6745*std(x);ek=abs(error-mean(error));pk=0;for i=1:nif ek(i,:)<s0pk=pk+1;endendP=pk/n; %计算小残差概率%附带的质料里有一部分讲了关联度function [rela]=relations(x)%以x(1,:)的参考序列求关联度[m,n]=size(x);for i=1:mfor j=n:-1:2x(i,j)=x(i,j)/x(i,1);endfor i=2:mx(i,:)=abs(x(i,:)-x(1,:)); %求序列差endc=x(2:m,:);Max=max(max(c)); %求两极差Min=min(min(c));p=0.5; %p称为分辨率,0<p<1,一般取p=0.5for i=1:m-1for j=1:nr(i,j)=(Min+p*Max)/(c(i,j)+p*Max); %计算关联系数endendfor i=1:m-1rela(i)=sum(r(i,:))/n; %求关联度end四，非线性拟合function f=example1(c,tdata)f=c(1)*(exp(-c(2)*tdata)-exp(-c(3)*tdata));<pre name="code" class="plain">function f=zhengtai(c,x) f=(1./(sqrt(2.*3.14).*c(1))).*exp(-(x-c(1)).^2./(2.*c( 2)^2));x=1:1:12;y=[01310128212]';c0=[2 8];for i=1:1000c=lsqcurvefit(@zhengtai,c0,x,y);c0=c;endy1=(1./(sqrt(2.*3.14).*c(1))).*exp(-(x-c(1)).^2./(2.*c (2)^2));plot(x,y,'r-',x,y1);legend('实验数据','拟合曲线')x=[0.25 0.5 0.75 1 1.5 2 2.5 3 3.5 4 4.5 5 6 7 8 9 10 11 12 13 14 15 16]';y=[30 68 75 82 82 77 68 68 58 51 50 41 38 35 28 25 18 15 12 10 7 7 4]';f=@(c,x)c(1)*(exp(-c(2)*x)-exp(-c(3)*x));c0=[114 0.1 2]';for i=1:50opt=optimset('TolFun',1e-3);[c R]=nlinfit(x,y,f,c0,opt)c0=c;hold onplot(x,c(1)*(exp(-c(2)*x)-exp(-c(3)*x)),'g')endt=[0.25 0.5 0.75 1 1.5 2 2.5 3 3.5 4 4.5 5 6 7 8 9 10 11 12 13 14 15 16];y=[30 68 75 82 82 77 68 68 58 51 50 41 38 35 28 25 18 15 12 10 7 7 4];c0=[1 1 1];for i=1:50 c=lsqcurvefit(@example1,c0,t,y);c0=c;endy1=c(1)*(exp(-c(2)*t)-exp(-c(3)*t));plot(t,y,' +',t,y1);legend('实验数据','拟合曲线')五，插值拟合相关知识在生产和科学实验中，自变量及因变量间的函数关系有时不能写出解析表达式，而只能得到函数在若干点的函数值或导数值，或者表达式过于复杂而需要较大的计算量。

数模十大常用算法及说明&参考文献

数模十大常用算法及说明1. 蒙特卡罗算法该算法又称随机性模拟算法，是通过计算机仿真来解决问题的算法，同时可以通过模拟来检验自己模型的正确性，几乎是比赛时必用的方法。

2. 数据拟合、参数估计、插值等数据处理算法比赛中通常会遇到大量的数据需要处理，而处理数据的关键就在于这些算法，通常使用MATLAB 作为工具。

3. 线性规划、整数规划、多元规划、二次规划等规划类算法建模竞赛大多数问题属于最优化问题，很多时候这些问题可以用数学规划算法来描述，通常使用Lindo 、Lingo 软件求解。

4. 图论算法这类算法可以分为很多种，包括最短路、网络流、二分图等算法，涉及到图论的问题可以用这些方法解决，需要认真准备。

5. 动态规划、回溯搜索、分治算法、分支定界等计算机算法这些算法是算法设计中比较常用的方法，竞赛中很多场合会用到。

6. 最优化理论的三大非经典算法：模拟退火算法、神经网络算法、遗传算法这些问题是用来解决一些较困难的最优化问题的，对于有些问题非常有帮助，但是算法的实现比较困难，需慎重使用。

7. 网格算法和穷举法两者都是暴力搜索最优点的算法，在很多竞赛题中有应用，当重点讨论模型本身而轻视算法的时候，可以使用这种暴力方案，最好使用一些高级语言作为编程工具。

8. 一些连续数据离散化方法很多问题都是实际来的，数据可以是连续的，而计算机只能处理离散的数据，因此将其离散化后进行差分代替微分、求和代替积分等思想是非常重要的。

9. 数值分析算法如果在比赛中采用高级语言进行编程的话，那些数值分析中常用的算法比如方程组求解、矩阵运算、函数积分等算法就需要额外编写库函数进行调用。

10. 图象处理算法赛题中有一类问题与图形有关，即使问题与图形无关，论文中也会需要图片来说明问题，这些图形如何展示以及如何处理就是需要解决的问题，通常使用MATLAB 进行处理。

十类算法的详细说明1．蒙特卡罗算法大多数建模赛题中都离不开计算机仿真，随机性模拟是非常常见的算法之一。

数学建模算法的matlab代码

数学建模算法的matlab代码句柄图形(图形窗口)二，hamiton回路算法提供一种求解最优哈密尔顿的算法---三边交换调整法，要求在运行jiaohuan3（三交换法）之前，给定邻接矩阵C和节点个数N，结果路径存放于R 中。

由于没有经过大量的实验，又是近似算法，对于网络比较复杂的情况，可以尝试多运行几次jiaohuan3,看是否能到进一步的优化结果。

%%%%%%bianquan.m%%%%%%%N=13;for i=1:Nfor j=1:NC(i,j)=inf;endendfor i=1:NC(i,i)=0;endC(1,2)=6.0;C(1,13)=12.9;C(2,3)=5.9;C(2,4)=10.3;C(3,4)=12.2;C(3,5)=17.6;C(4,13)=8.8;C(4,7)=7.4;C(4,5)=11.5;C(5,2)=17.6;C(5,6)=8.2;C(6,9)=14.9;C(6,7)=20.3;C(7,9)=19.0;C(7,8)=7.3;C(8,9)=8.1;C(8,13)=9.2;C(9,10)=10.3;C(10,11)=7.7;C(11,12)=7.2;C(12,13)=7.9;for i=1:Nfor j=1:Nif C(i,j) < infC(j,i)=C(i,j);endendendfor i=1:NC(i,i)=0;endR=[4 7 6 5 3 2 1 13 12 11 10 9 8]; %%%%%%%%jiaohuan3.m%%%%%%%%%% n=0; for I=1:(N-2)for J=(I+1):(N-1)for K=(J+1):Nn=n+1;Z(n,:)=[I J K];endendendR=1:Nfor m=1:(N*(N-1)*(N-2)/6)I=Z(m,1);J=Z(m,2);K=Z(m,3);r=R;if J-I~=1&K-J~=1&K-I~=N-1for q=1:(J-I)r(I+q)=R(J+1-q);endfor q=1:(K-J)r(J+q)=R(K+1-q);endendif J-I==1&K-J==1r(K)=R(J);r(J)=R(K);endif J-I==1&K-J~=1&K-I~=N-1 for q=1:(K-J)r(I+q)=R(I+1+q);endr(K)=R(J);endif K-J==1&J-I~=1&K~=N for q=1:(J-I)r(I+1+q)=R(I+q);endr(I+1)=R(K);endif I==1&J==2&K==Nfor q=1:(N-2)r(1+q)=R(2+q);endr(N)=R(2);endif I==1&J==(N-1)&K==N for q=1:(N-2)r(q)=R(1+q);endr(N-1)=R(1);endif J-I~=1&K-I==N-1for q=1:(J-1)r(q)=R(1+q);endr(J)=R(1);endif J==(N-1)&K==N&J-I~=1r(J+1)=R(N);for q=1:(N-J-1)r(J+1+q)=R(J+q);endendif cost_sum(r,C,N)<cost_sum(r,c,n)< p="">R=rendendfprintf('总长为%f\n',cost_sum(R,C,N))%%%%%%cost_sum.m%%%%%%%%functiony=cost_sum(x,C,N)y=0;for i=1:(N-1) y=y+C(x(i),x(i+1));endy=y+C(x(N),x(1));三，灰色预测代码clearclcX=[136 143 165 152 165 181 204 272 319 491 571 605 665 640 628];x1(1)=X(1);X1=[];for i=1:1:14x1(i+1)=x1(i)+X(i+1);X1=[X1,x1(i)];endX1=[X1,X1(14)+X(15)]for k=3:1:15p(k)=X(k)/X1(k-1);p1(k)=X1(k)/X1(k-1);endp,p1clear kZ=[];for k=2:1:15z(k)=0.5*X1(k)+0.5*X1(k-1);Z=[Z,z(k)];endZB=[-Z',ones(14,1)]Y=[];clear ifor i=2:1:15Y=[Y;X(i)];endYA=inv(B'*B)*B'*Yclear ky1=[];for k=1:1:15y(k)=(X(1)-A(2)/A(1))*exp(-A(1)*(k-1))+A(2)/A(1); y1=[y1;y(k)];endy1clear kX2=[];for k=2:1:15x2(k)=y1(k)-y1(k-1);X2=[X2;x2(k)];endX2=[y1(1);X2]e=X'-X2m=abs(e)./X's=e'*en=sum(m)/13clear ksyms ky=(X(1)-A(2)/A(1))*exp(-A(1)*(k-1))+A(2)/A(1)Y1=[];for j=16:1:21y11=subs(y,k,j)-subs(y,k,j-1);Y1=[Y1;y11];endY1%程序中的变量定义:alpha是包含α、μ值的矩阵;%ago是预测后累加值矩阵;var是预测值矩阵;%error是残差矩阵; c是后验差比值function basicgrey(x,m) %定义函数basicgray(x)if nargin==1 %m 为想预测数据的个数，默认为1 m=1;endclc; %清屏,以使计算结果独立显示if length(x(:,1))==1 %对输入矩阵进行判断,如不是一维列矩阵,进行转置变换x=x';endn=length(x); %取输入数据的样本量x1(:,1)=cumsum(x); %计算累加值,并将值赋与矩阵be for i=2:n %对原始数列平行移位Y(i-1,:)=x(i,:);endfor i=2:n %计算数据矩阵B的第一列数据z(i,1)=0.5*x1(i-1,:)+0.5*x1(i,:);endB=ones(n-1,2); %构造数据矩阵BB(:,1)=-z(2:n,1);alpha=inv(B'*B)*B'*Y; %计算参数α、μ矩阵for i=1:n+m %计算数据估计值的累加数列,如改n+1为n+m可预测后m个值ago(i,:)=(x1(1,:)-alpha(2,:)/alpha(1,:))*exp(-alpha(1,:)*(i-1))+alpha(2,:)/alpha(1,:);endvar(1,:)=ago(1,:);for i=1:n+m-1 %可预测后m个值var(i+1,:)=ago(i+1,:)-ago(i,:); %估计值的累加数列的还原,并计算出下m个预测值end[P,c,error]=lcheck(x,var); %进行后验差检验[rela]=relations([x';var(1:n)']); %关联度检验ago %显示输出预测值的累加数列alpha %显示输出参数α、μ数列var %显示输出预测值error %显示输出误差P %显示计算小残差概率 c %显示后验差的比值crela %显示关联度judge(P,c,rela) %评价函数显示这个模型是否合格function judge(P,c,rela)%评价指标并显示比较结果if rela>0.6'根据经验关联度检验结果为满意（关联度只是参考主要看后验差的结果）' else'根据经验关联度检验结果为不满意（关联度只是参考主要看后验差的结果）' endif P>0.95&c<0.5'后验差结果显示这个模型评价为“优”'else if P>0.8&c<0.5'后验差结果显示这个模型评价为“合格”'else if P>0.7&c<0.65'后验差结果显示这个模型评价为“勉强合格”'else'后验差结果显示这个模型评价为“不合格”'endendendfunction [P,c,error]=lcheck(x,var)%进行后验差检验n=length(x);for i=1:nerror(i,:)=abs(var(i,:)-x(i,:)); %计算绝对残差endc=std(abs(error))/std(x); %调用统计工具箱的标准差函数计算后验差的比值cs0=0.6745*std(x);ek=abs(error-mean(error));pk=0;for i=1:nif ek(i,:)<s0< p="">pk=pk+1;endendP=pk/n; %计算小残差概率%附带的质料里有一部分讲了关联度function [rela]=relations(x)%以x(1,:)的参考序列求关联度[m,n]=size(x);for i=1:mfor j=n:-1:2x(i,j)=x(i,j)/x(i,1);endendfor i=2:mx(i,:)=abs(x(i,:)-x(1,:)); %求序列差endc=x(2:m,:);Max=max(max(c)); %求两极差Min=min(min(c));p=0.5; %p称为分辨率,0<p< p="">for i=1:m-1for j=1:nr(i,j)=(Min+p*Max)/(c(i,j)+p*Max); %计算关联系数endendfor i=1:m-1rela(i)=sum(r(i,:))/n; %求关联度end四，非线性拟合function f=example1(c,tdata)f=c(1)*(exp(-c(2)*tdata)-exp(-c(3)*tdata));function f=zhengtai(c,x)f=(1./(sqrt(2.*3.14).*c(1))).*exp(-(x-c(1)).^2./(2.*c(2)^2));x=1:1:12;y=[01310128212]';c0=[2 8];for i=1:1000c=lsqcurvefit(@zhengtai,c0,x,y);c0=c;endy1=(1./(sqrt(2.*3.14).*c(1))).*exp(-(x-c(1)).^2./(2.*c(2)^2));plot(x,y,'r-',x,y1);legend('实验数据','拟合曲线')x=[0.25 0.5 0.75 1 1.5 2 2.5 3 3.5 4 4.5 5 6 7 8 9 10 11 12 13 14 15 16]';y=[30 68 75 82 82 77 68 68 58 51 50 41 38 35 28 25 18 15 12 10 7 7 4]';f=@(c,x)c(1)*(exp(-c(2)*x)-exp(-c(3)*x));c0=[114 0.1 2]';for i=1:50opt=optimset('TolFun',1e-3);[c R]=nlinfit(x,y,f,c0,opt)c0=c;hold onplot(x,c(1)*(exp(-c(2)*x)-exp(-c(3)*x)),'g')endt=[0.25 0.5 0.75 1 1.5 2 2.5 3 3.5 4 4.5 5 6 7 8 9 10 11 12 1314 15 16];y=[30 68 75 82 82 77 68 68 58 51 50 41 38 35 28 25 1815 12 10 7 7 4];c0=[1 1 1];for i=1:50 c=lsqcurvefit(@example1,c0,t,y);c0=c;endy1=c(1)*(exp(-c(2)*t)-exp(-c(3)*t));plot(t,y,'+',t,y1);legend('实验数据','拟合曲线')五，插值拟合相关知识在生产和科学实验中，自变量与因变量间的函数关系有时不能写出解析表达式，而只能得到函数在若干点的函数值或导数值，或者表达式过于复杂而需要较大的计算量。

数学建模代码汇总

数学建模代码汇总插值% 产生原始数据x=0:0.1:1;y=(x.^2-3*x+7).*exp (-4*x).*sin (2*x); % 线性插值xx=0:0.01:1;y1=interp1 (x,y,xx,'linear');subplot (2,2,1)plot (x,y,'o',xx,y1);title ('线性插值');% 最邻近点插值y2=interp1 (x,y,xx,'nearest'); subplot (2,2,2)plot (x,y,'o',xx,y2);title ('最邻近点插值');% 三次插值y3=interp1 (x,y,xx,'cubic');subplot (2,2,3)plot (x,y,'o',xx,y3);title ('三次插值');% 三次样条插值y4=interp1 (x,y,xx,'spline');subplot (2,2,4)plot (x,y,'o',xx,y4);title ('三次样条插值');% 插值基点为网格节点clear ally=20:-1:0;x=0:20;z=[0.2 0.2 0.2 0.2 0.2 0.2 0.4 0.4 0.3 0.2 0.3 0.2 0.1 0.2 0.2 0.4 0.3 0.2 0.20.2 0.2;0.3 0.2 0.2 0.2 0.2 0.4 0.3 0.3 0.3 0.3 0.4 0.2 0.2 0.2 0.2 0.4 0.4 0.4 0.3 0.20.2;0.2 0.3 0.3 0.2 0.3 1 0.4 0.5 0.3 0.3 0.3 0.3 0.2 0.2 0.2 0.6 0.5 0.4 0.4 0.20.2;0.2 0.2 0.4 0.2 1 1.1 0.9 0.4 0.3 0.3 0.5 0.3 0.2 0.2 0.2 0.7 0.3 0.6 0.6 0.30.4;0.2 0.2 0.9 0.7 1 1 1 0.7 0.5 0.3 0.2 0.2 0.2 0.6 0.2 0.8 0.7 0.9 0.5 0.50.4;0.2 0.3 1 1 1 1.2 1 1.1 0.8 0.3 0.2 0.2 0.2 0.5 0.3 0.6 0.6 0.8 0.7 0.60.5;0.2 0.4 1 1 1.1 1.1 1.1 1.1 0.6 0.3 0.4 0.4 0.2 0.7 0.5 0.9 0.7 0.4 0.9 0.80.3;0.2 0.2 0.9 1.1 1.2 1.2 1.1 1.1 0.6 0.3 0.5 0.3 0.2 0.4 0.3 0.7 1 0.7 1.2 0.80.4;0.2 0.3 0.4 0.9 1.1 1 1.1 1.1 0.7 0.4 0.4 0.4 0.3 0.5 0.5 0.8 1.1 0.8 1.1 0.90.3;0.3 0.3 0.5 1.2 1.2 1.1 1 1.2 0.9 0.5 0.6 0.4 0.6 0.6 0.3 0.6 1.2 0.8 1 0.80.3 0.5 0.9 1.1 1.1 1 1.2 1 0.8 0.7 0.5 0.6 0.4 0.5 0.4 1 1.3 0.9 0.9 10.8;0.3 0.5 0.6 1.1 1.2 1 1 1.1 0.9 0.4 0.4 0.5 0.5 0.8 0.6 0.9 1 0.5 0.8 0.80.9;0.4 0.5 0.4 1 1.1 1.2 1 0.9 0.7 0.5 0.6 0.3 0.6 0.4 0.6 1 1 0.6 0.9 10.7;0.3 0.5 0.8 1.1 1.1 1 0.8 0.7 0.7 0.4 0.5 0.4 0.4 0.5 0.4 1.1 1.3 0.7 1 0.70.6;0.3 0.5 0.9 1.1 1 0.7 0.7 0.4 0.6 0.4 0.4 0.3 0.5 0.5 0.3 0.9 1.2 0.8 1 0.80.4;0.2 0.3 0.6 0.9 0.8 0.8 0.6 0.3 0.4 0.5 0.4 0.5 0.4 0.2 0.5 0.5 1.3 0.6 1 0.90.3;0.2 0.3 0.3 0.7 0.6 0.6 0.4 0.2 0.3 0.5 0.8 0.8 0.3 0.2 0.2 0.8 1.3 0.9 0.8 0.80.4;0.2 0.3 0.3 0.6 0.3 0.4 0.3 0.2 0.2 0.3 0.6 0.4 0.3 0.2 0.4 0.3 0.8 0.6 0.7 0.40.4;0.2 0.3 0.4 0.4 0.2 0.2 0.2 0.3 0.2 0.2 0.2 0.2 0.2 0.2 0.2 0.5 0.7 0.4 0.4 0.30.3;0.2 0.2 0.3 0.2 0.2 0.3 0.2 0.2 0.2 0.2 0.2 0.1 0.2 0.4 0.3 0.6 0.5 0.3 0.3 0.30.2 0.2 0.2 0.2 0.2 0.2 0.2 0.2 0.2 0.2 0.2 0.2 0.2 0.2 0.4 0.7 0.4 0.2 0.4 0.50.5];% 未插值直接画图figure (1) % 创建图形窗口1，并激活surf (x,y,z);shading flat % 用shading flat命令，使曲面变的光滑title ('未插值地形图')xlabel ('横坐标')ylabel ('纵坐标')zlabel ('高度')% 三次插值后画图% 画地形图figure (2)xi=0:0.05:20;yi=20:-0.05:0;zi=interp2 (x,y,z,xi',yi,'cubic'); %'cubic'三次插值surfc (xi,yi,zi); % 底面带等高线shading flattitle ('插值后地形图')xlabel ('横坐标')ylabel ('纵坐标')zlabel ('高度')% 画立体等高线图figure (3)contour3 (xi,yi,zi);title ('立体等高线图')xlabel ('横坐标')ylabel ('纵坐标')zlabel ('高度')% 画等高线图figure (4)[c,h]=contour (xi,yi,zi);clabel (c,h); % 用于为2维等高线添加标签colormap cool % 冷色调title ('平面等高线图')xlabel ('横坐标')ylabel ('纵坐标')ge回归拟合function yhat=Logisfun (beta,x)yhat=beta (1)./(1+(beta (1)/beta(2)-1).*exp (-beta(3).*x));clear ally=[3.9 5.3 7.2 9.6 12.9 17.1 23.2 31.4 38.6 50.2 62.9...76.0 92.0 106.5 123.2 131.7 150.7 179.3 204.0 226.5 251.4 281.4]';x=(1:22)';beta0=[400,3.0,0.20]';% 非线性回归'Logisfun'为回归模型[beta,r,j]=nlinfit (x,y,'Logisfun',beta0);% beta0为回归系数初始迭代点% beta为回归系数% r为残差% 输出拟合表达式:fprintf ('回归方程为y=%5 .4f/(1+%5 .4f*exp (-%5.4f*x))\n',beta (1),beta (1)/beta(2)-1,beta (3)) % 求均方误差根: 精选文库rmse=sqrt (sum (r.^2)/22);rmse% 预测和误差估计：[Y,DELTA]=nlpredci ('Logisfun',x,beta,r,j);% DELTA为误差限% Y为预测值(拟合后的表达式求值)plot (x,Y,x,y,'o',x,Y+DELTA,':',x,Y-DELTA,':')% lny=lna+bxclear ally=[3.9 5.3 7.2 9.6 12.9 17.1 23.2 31.4 38.6 50.2 62.9 76.0];% Y为列向量Y=log (y');x=1:12;% X为两列X=[ones (12,1),x'];[b,bint,r,rint,stats]=regress (Y,X);% b为参数的点估计disp ('b为参数的点估计')b% bint为参数的区间估计disp ('bint为参数的区间估计')bint% stats (1)为相关系数越接近1回归方程越显著disp ('stats (1)')stats (1)% stats (2)为F值越大回归越显著disp ('stats (2)')stats (2)% stats (3)为与F对应的概率P P<a时模型成立< bdsfid="213" p=""></a时模型成立<>disp ('stats (3)')stats (3)% 求均方误差根RMSEa=exp (b (1));yy=a.*exp (b (2).*x);rmse=sqrt (sum ((yy-y).^2)/12);disp ('rmse')rmse% 写出表达式fprintf ('回归方程为y=%5 .4f*exp (%5 .4fx)',a,b (2))% 做回归图像figure (1)plot (x,y,'o',x,yy)% 做参差图精选文库figure (2)rcoplot (r,rint)% 先把所有的红线点蓝，再点All steps键，变红的量就是要剔除的量x1=[7 1 11 11 7 11 3 1 2 21 1 11 10]';x2=[26 29 56 31 52 55 71 31 54 47 40 66 68]';x3=[6 15 8 8 6 9 17 22 18 4 23 9 8]';x4=[60 52 20 47 33 22 6 44 22 26 34 12 12]';X=[x1 x2 x3 x4];Y=[78.5 74.3 104.3 87.6 95.9 109.2 102.7 72.5 93.1 115.9 83.8 113.3 109.4]';stepwise (X,Y)神经网络% 利用神经网络进行函数逼近clear allx=0:0.1*pi:4*pi;y=sin (x);net.trainparam.epochs=10000;% 网络初始化net=newff([0,4*pi],[8,8,8,8,1],{'tansig','logsig','logsig','tansig','tansig'});% 训练网络[net,tr,y1,e]=train (net,x,y);X=0:0.01*pi:4*pi;% 网络泛化y2=sim (net,X);subplot (2,1,2);plot (X,y2);title ('网络产生')grid onsubplot (2,1,1);plot (x,y,'o');title ('原始数据')grid on% 利用神经网络进行分类clear allx=[1.24 1.36 1.38 1.38 1.38 1.40 1.48 1.54 1.56 1.14 1.18 1.20 1.26 1.28 1.30;...1.72 1.74 1.64 1.82 1.90 1.70 1.82 1.822.08 1.78 1.96 1.86 2.0 2.0 1.96];y=[1 1 1 1 1 1 1 1 1 0 0 0 0 0 0;...0 0 0 0 0 0 0 0 0 1 1 1 1 1 1];xmin1=min (x (1,:));xmax1=max (x (1,:));xmin2=min (x (2,:));xmax2=max (x (2,:));net.trainparam.epochs=10000;% 网络初始化net=newff([xmin1,xmax1;xmin2,xmax2],[8,8,8,8,2],{'tansig','logsig','logsig','t ansig','tansig'}); % 训练网络[net,tr,y1,e]=train (net,x,y);X=[1.24 1.28 1.40;...1.80 1.842.04];% 网络泛化y2=sim (net,X)plot (x (1,1:9),x (2,1:9),'o',x (1,10:15),x (2,10:15),'*',X (1,:),X (2,:),'v')grid on数值积分与函数极值实验% 一重积分% 求利用符号函数求理论值syms x;y=exp (-x^2); % 被积函数s=int (y,x,0,1); % 调用int函数v=vpa (s); % 将符号表达式转化为数值% 利用quad函数进行数值积分f1=inline ('exp (-x.^2)','x'); % 被积函数y1=quad (f1,0,1);% 二重积分f2=inline ('exp ((-x.^2)/2).*sin (x.^2+y)','x','y');y2=dblquad (f2,-2,2,-1,1);% 三重积分f3=inline ('4*x.*z.*exp (-(x.^2).*y-z.^2)','x','y','z');y3=triplequad (f3,0,2,0,pi,0,pi);clear allsyms x;y=(x^2-1)^3+1;y1=diff (y,x); % y对x求一阶导y2=diff (y,x,2); % y对x求二阶导subplot (3,1,1); % 把图形窗口分成3*1部分，并激活第1部分ezplot (y,[-1.5,1.5]); % 对符号函数在[-1.5,1.5]上绘图subplot (3,1,2);ezplot (y1,[-1.5,1.5]);subplot (3,1,3);ezplot (y2,[-1.5,1.5]);% 通过导数为0的点求最值x0=solve ('6*(x^2-1)^2*x=0','x'); % 求解一阶导数(从workspace中得到)为0的点y0=subs (y,x,x0); % 把x0带入y中的x[ymin1,n]=min (eval (y0)); % 求y0的最小值xmin1=x0 (n);% 通过fminbnd求函数最值f=inline ('(x^2-1)^3+1','x');xmin2=fminbnd (f,-1.5,1.5); % 在[-1.5,1.5]上求f函数的最小值点ymin2=f (xmin2);无约束优化clear all% 无约束优化的经典算法与非经典算法比较% 使用rosenbrock函数,理论极值为0if exist ('rosenbrock.m')==0disp ('没有为方程创建名为rosenbrock.m的函数文件,请建立它');end% 画图[x,y]=meshgrid (-1:0.05:1,-1:0.05:1);z=100*(y-x.^2).^2+(1-x).^2;surf (x,y,z)% 经典算法:[x1,fval1,exitflag1,output1]=fminunc ('rosenbrock',[0,0]);% 初始点为(0,0)% x为解% fval为目标函数x处的值% exitflag>0表示函数已收敛到x处% output中:Iterations表示迭代次数% Algorithm表示采用算法% FuncCount表示函数评价次数% 遗传算法% 调整最大允许的代数1万代,种群规模为200options=gaoptimset('Generations',10000,'PopulationSize',200);% 设置两个变量,限制0<=x1,x2<=2[x2,fval2,exitflag2,output2]=ga (@rosenbrock,2,[1,0;0,1;-1,0;0,-1],[2;2;0;0],[],[],[],[],[],options); % exiflag>0表示求解成功function y=rosenbrock (x)y=100*(x (2)-x (1).^2).^2+(1-x (1)).^2;通用function [s,c]=circle (r) % 注意此文件名一定要为circle.m% CIRCLE 计算半径为r的圆面积与周长%[s,c]=circle (r)% r圆半径,s圆面积,c圆周长%2008 年9月19日编写s=pi*r*r;c=2*pi*r;function [s,c]=circle (r) % 注意此文件名一定要为circle.m% CIRCLE 计算半径为r的圆面积与周长%[s,c]=circle (r)% r圆半径,s圆面积,c圆周长%2008 年9月19日编写s=pi*r*r;c=2*pi*r;追击仿真function y=f (x)if x==1y=2;endif x==2y=3;endif x==3y=4;endif x==4y=1;end% 四人追逐问题实验% f.m文件用于调节追击次序即第一人追第二人，第二人追第三人，第三人追第四人，第四人追第五人D=2; % 最小距离v=10; % 速度dt=0.1; % 时间间隔x=zeros (4,103); % 四个人的横坐标y=zeros (4,103); % 四个人的纵坐标x (1,1)=100;y (1,1)=0; % 第一个人的初始坐标（100，0）x (2,1)=0;y (2,1)=0; % 第二个人的初始坐标（0，0）x (3,1)=0;y (3,1)=100; % 第三个人的初始坐标（0，100）x (4,1)=100;y (4,1)=100; % 第四个人的初始坐标（100，100）k=1;t=0;% 追击模拟while (sqrt ((x (1,k)-x (2,k))^2+(y (1,k)-y (2,k))^2)>D)k=k+1;t=t+dt;for i=1:4d=sqrt ((x (f (i),k-1)-x (i,k-1))^2+(y (f (i),k-1)-y (i,k-1))^2); % 两人距离cosx=(x (f (i),k-1)-x (i,k-1))/d;sinx=(y (f (i),k-1)-y (i,k-1))/d;x (i,k)=x (i,k-1)+v*cosx*dt; % 求新的x坐标y (i,k)=y (i,k-1)+v*sinx*dt; % 求新的y坐标endend% 描绘追击图像for i=1:kplot (x (1,i),y (1,i),'o',x (2,i),y (2,i),'*',x (3,i),y (3,i),'o',x (4,i),y (4,i),'*')pause (0.01);hold onend动态规划clear allclc% max z=g1 (x1)+g2 (x2)+g3 (x3)% x1+x2+x3=n;0<=xi<=n% 算法：突出阶段的动态规划% f1 (x)=g1 (x) 0<=x<=n% fi (x)=max {gi (y)+fi-1(x-y)} 0<=x<=n,0<=y<=n% 数据结构n=7;% 总金额m=3;% 阶段数income=[0,0.11,0.13,0.15,0.21,0.24,0.30,0.35;0,0.12,0.16,0.21,0.23,0.25,0.24,0.34;0,0.08,0.12,0.2,0.24,0.26,0.30,0.35];% 三个项目的收益income (k,i) k阶段投资i-1的收益f=zeros (3,8);% f (k,i) 当前投资i-1最大收益a=zeros (3,8);% a (i,j) 前i个工程投资j-1所获得最大利润时，给i项目的投资f (1,:)=income (1,:);a (1,:)=[0,1,2,3,4,5,6,7];% 动态规划for k=2:m % 阶段for j=0:n % 到本阶段为止总投资量for i=0:j % 前一阶段投资量if f (k-1,i+1)+income (k,j-i+1)>=f (k,j+1)f (k,j+1)=f (k-1,i+1)+income (k,j-i+1);a (k,j+1)=j-i;% 本阶段投资量end % ifend % forend % forend % for% 出结果f (m,n+1)out=n+1;for i=m:-1:1a (i,out)out=out-a (i,out);end % for残缺棋盘function [board,amount]=cover (i,j,k,l,board,size,amount)% (i,j)为左上角(k,l)残缺size为规模amount为片数if size==1returnendamount=amount+1;size=size/2;if (k<size+i)&(l<=""></size+i)&(lboard (size+i-1,size+j)=amount;board (size+i,size+j)=amount;board (size+i,size+j-1)=amount;% 放置[board,amount]=cover(i,j,k,l,board,size,amount);[board,amount]=cover (i,j+size,size+i-1,j+size,board,size,amount);[board,amount]=cover(size+i,size+j,size+i,size+j,board,size,amount);[board,amount]=c over (i+size,j,i+size,j+size-1,board,size,amount);elseif (k>=size+i)&(l<="">board (size+i-1,size+j)=amount;board (size+i,size+j)=amount;board (size+i-1,size+j-1)=amount;% 放置[board,amount]=cover(i+size,j,k,l,board,size,amount);[board,amount]=cover(i,j+size,size+i-1,j+size,board,size,amount);[board,amount]=cover(size+i,size+j,size+i,size+j,board,size,amount);[board,amount]=c over (i,j,i+size-1,j+size-1,board,size,amount);elseif (k<size+i)&(l bdsfid="457">=size+j)% 残缺位于右上棋盘</size+i)&(l>board (size+i,size+j-1)=amount;board (size+i,size+j)=amount;board (size+i-1,size+j-1)=amount;% 放置[board,amount]=cover(i,j+size,k,l,board,size,amount);[board,amount]=cover (i,j,i+size-1,j+size-1,board,size,amount);[board,amount]=cover(size+i,size+j,size+i,size+j,board,size,amount);[board,amount]=c over (i+size,j,i+size,j+size-1,board,size,amount);elseif (k>=size+i)&(l>=size+j)% 残缺位于右下棋盘board (size+i,size+j-1)=amount;board (size+i-1,size+j)=amount;board (size+i-1,size+j-1)=amount;% 放置[board,amount]=cover(size+i,size+j,k,l,board,size,amount);[board,amount]=cover (i,j+size,size+i-1,j+size,board,size,amount);[board,amount]=cover (i,j,i+size-1,j+size-1,board,size,amount);[board,amount]=cover(i+size,j,i+size,j+size-1,board,size,amount);endend% 残缺棋盘board=zeros (100,100);n=4;size=2^n;amount=0;[board,amount]=cover (1,1,2,5,board,size,amount);board (1:size,1:size)广度优先搜索function y=check (i,j,maze)if (i<=8)&(j<=8)&(i>=1)&(j>=1)y=1;elsey=0;returnendif maze (i,j)==1|maze (i,j)==-1y=0;returnendclear allclcmaze=[0,0,0,0,0,0,0,0;0,1,1,1,1,0,1,0;0,0,0,0,1,0,1,0;0,1,0,0,0,0,1,0;0,1,0,1,1,0,1,0;0,1,0,0,0,0,1,1;0,1,0,0,1,0,0,0;0,1,1,1,1,1,1,0];% 迷宫:0为路,1为墙,-1为遍历过fx (1:4)=[1,-1,0,0];fy (1:4)=[0,0,-1,1];精选文库sq.pre=zeros (1,100);sq.x=zeros (1,100);sq.y=zeros (1,100); qh=0;% 队头指针qe=1;% 队尾指针maze (1,1)=-1;% 第一个元素入队sq.pre(1)=0;sq.x(1)=1;sq.y(1)=1;while qh-qe~=0qh=qh+1;bb=0;for k=1:4i=sq.x(qh)+fx (k);j=sq.y(qh)+fy (k);if check (i,j,maze)==1qe=qe+1;% 入队sq.x(qe)=i;sq.y(qe)=j;sq.pre(qe)=qh;maze (i,j)=-1;if i==8&j==8% 如果为图最后一个点while qe~=0sq.x(qe)sq.y(qe)qe=sq.pre(qe);endbb=1;break;end % ifend % ifendif bb==1breakendend % while回溯n皇后function [chess,row,main,deputy,number]=justtry (i,n,chess,row,main,deputy,number);for k=1:8if row (k)==0&main (i-k+n)==0&deputy (i+k-1)==0% 此棋盘可继续放子chess (i,k)=1;row (k)=1;main (i-k+n)=1;deputy (i+k-1)=1;if i==8% 如果棋盘搜索结束number=number+1chesselse % 没有结束继续深搜[chess,row,main,deputy,number]=justtry(i+1,n,chess,row,main,deputy,number);% 递归end chess (i,k)=0;% 回溯row (k)=0;main (i-k+n)=0;deputy (i+k-1)=0;endendclear allclc% n皇后问题n=8;chess=zeros (n,n);row=zeros (1,n);% 记录n列被占用的情况main=zeros (1,2*n-1);% 记录主对角线的使用情况deputy=zeros (1,2*n-1);% 记录从对角线的使用情况number=0;[chess,row,main,deputy,number]=justtry(1,n,chess,row,main,deputy,number);密宫所有路clear allclcmaze=[0,0,0,0,0,0,0,0;0,1,1,1,1,0,1,0;0,0,0,0,1,0,1,0;0,1,0,0,0,0,1,0;0,1,0,1,1,0,1,0;0,1,0,0,0,0,1,1;0,1,0,0,1,0,0,0;0,1,1,1,1,1,1,0];% 迷宫：0为路，1为墙，2为遍历过total=0;maze (1,1)=2;[total,maze]=search (1,1,maze,total);function [total,maze]=search (i,j,maze,total);fx (1:4)=[1,0,-1,0];fy (1:4)=[0,1,0,-1];for k=1:4newi=i+fx (k);newj=j+fy (k);if (newi<=8)&(newj<=8)&(newi>=1)&(newj>=1)&maze (newi,newj)==0maze (newi,newj)=2;% 此点已走if newi==8&newj==8mazeelse[total,maze]=search (newi,newj,maze,total);end % if i+fx (k)==8&j+fy (y)==8maze (newi,newj)=0;% 回溯end % if (newi<=8)&(newj<=8)&(newi>=1)&(newj>=1)&maze (newi,newj)==0end % for k=1:4end排列树的回溯搜索function [chess,main,deputy,number]=justtry (i,n,chess,main,deputy,number);if i==9number=number+1chesselsefor k=i:8if main (i-chess (k)+n)==0&deputy (i+chess (k)-1)==0% 此棋盘可继续放子(主，副对角线可放子)t=chess (k);% 交换chess (k)=chess (i);chess (i)=t;main (i-chess (k)+n)=1;deputy (i+chess (k)-1)=1;[chess,main,deputy,number]=justtry(i+1,n,chess,main,deputy,number);% 递归t=chess (k);% 回溯chess (k)=chess (i);chess (i)=t;main (i-chess (k)+n)=0;deputy (i+chess (k)-1)=0;endendendend % functionclear allclc% n皇后问题n=8;chess=zeros (1,n);for i=1:n % 排列树chess (i)=i;endmain=zeros (1,2*n-1);% 记录主对角线的使用情况deputy=zeros (1,2*n-1);% 记录从对角线的使用情况[chess,main,deputy,number]=justtry(1,n,chess,main,deputy,number);。

十类数学建模中的算法

十类数学建模中的算法1、蒙特卡罗算法：在大多数建模赛题中都离不开计算机的仿真，随机性模拟是非常常见的算法之一。

# Y) b; b' E" _5 ~/ H举个例子就是97年的A题，每个零件都有自己的标定值，也都有自己的容差等级，而求解最优的组合方案将要面对着的是一个极其复杂的公式和108种容差选取方案，根本不可能去解析求解的，那如何去找到最优的方案呢？随机性模拟搜索最优方案就是其中的一种方法，在每个零件可行的区间中按照正态分布随机的选取一个标定值和选取一个容差值作为一种方案，然后通过蒙特卡罗算法仿真出大量的方案，从中选取一个最佳的。

另一个例子就是去年的彩票第二问，要求设计一种更好的方案，首先方案的优劣决定于很多复杂的因素，同样不可能刻画出一个模型进行求解，只能靠随机仿真模拟。

! Z* ?. W#W n, c5 0 g2、数据拟合、参数估计、插值等算法：数据拟合在很多赛题中有应用，与图形处理有关的问题很多与拟合有关系，一个例子就是98年美赛A题，生物组织切片的三维插值处理，94年A题逢山开路，山体海拔高度的插值计算，还有吵的沸沸扬扬可能会考的非典问题也要用到数据拟合算法，观察数据的走向进行处理。

此类问题在Matlab中有很多数据处理现成的函数可以调用，熟悉Matlab，这些方法都能游刃有余的做好。

3、规划类问题算法：竞赛中很多问题都和数学规划有关，可以说不少的模型都可以归结为一组不等式组作为约束条件、几个函数表达式作为目标函数的问题，遇到这类问题，求解就是关键了，比如98B，用很多不等式完全可以把问题刻画清楚，因此列举出规划后用Lindo、Lingo等软件来进行解决比较方便，所以还需要熟悉这两个软件。

T: y# q' F1 ~% ~$ K4、图论问题：98B、00B、95锁具装箱等问题体现了图论问题的重要性，这类问题算法有很多，包括：Dijkstra、Floyd、Prim、Bellman-Ford，最大流，二分匹配等问题。

数学建模代码

end
if(a8 < 5)
s=s+1;
else %s=s;
end
sample(i,j,ma) = image(i,j); %要更新背景样本时从20个样本中选取差值最大的那个更新
% 随机改变(i,j)某个背景邻域像素点的某个样本值
randy = round(rand)*2-1;%产生0-1之间的数，四舍五入为0或1，然后乘以2，减去1，得到的不是-1就是1
a5=abs(double(image(i,j)) - double(image5(i,j)));
a6=abs(double(image(i,j)) - double(image6(i,j)));
a7=abs(double(image(i,j)) - double(image7(i,j)));
for j = 1:width
div = abs(sample(i,j,:) - double(image(i,j)));
ma = find(div == (max(max(max(div)))));
logic = div < r;
end
if(a3 < 5)
s=s+1;
else %s=s;
end
imageRGB4 = read(video,f-4);
imageRGB5 = read(video,f-5);
imageRGB6 = read(video,f-6);
imageRGB7 = read(video,f-7);
imageRGB8 = read(video,f-8);
image = rgb2gray(imageRGB);

数学建模的十大算法

数学建模的十大算法一、蒙特卡罗算法1946年，美国拉斯阿莫斯国家实验室的三位科学家John von Neumann,Stan Ulam 和 Nick Metropolis共同发明了，蒙特卡罗方法。

蒙特卡罗方法（Monte Carlo method），又称随机抽样或统计模拟方法，是一种以概率统计理论为指导的一类非常重要的数值计算方法。

此方法使用随机数（或更常见的伪随机数）来解决很多计算问题的方法。

由于传统的经验方法由于不能逼近真实的物理过程，很难得到满意的结果，而蒙特卡罗方法由于能够真实地模拟实际物理过程，故解决问题与实际非常符合，可以得到很圆满的结果。

蒙特卡罗方法的基本原理及思想如下：当所求解问题是某种随机事件出现的概率，或者是某个随机变量的期望值时，通过某种“实验”的方法，以这种事件出现的频率估计这一随机事件的概率，或者得到这个随机变量的某些数字特征，并将其作为问题的解。

有一个例子可以使你比较直观地了解蒙特卡洛方法：假设我们要计算一个不规则图形的面积，那么图形的不规则程度和分析性计算（比如，积分）的复杂程度是成正比的。

蒙特卡洛方法是怎么计算的呢？假想你有一袋豆子，把豆子均匀地朝这个图形上撒，然后数这个图形之中有多少颗豆子，这个豆子的数目就是图形的面积。

当你的豆子越小，撒的越多的时候，结果就越精确。

在这里我们要假定豆子都在一个平面上，相互之间没有重叠。

蒙特卡罗方法通过抓住事物运动的几何数量和几何特征，利用数学方法来加以模拟，即进行一种数字模拟实验。

它是以一个概率模型为基础，按照这个模型所描绘的过程，通过模拟实验的结果，作为问题的近似解。

蒙特卡罗方法与一般计算方法有很大区别，一般计算方法对于解决多维或因素复杂的问题非常困难，而蒙特卡罗方法对于解决这方面的问题却比较简单。

其特点如下：I、直接追踪粒子，物理思路清晰，易于理解。

II、采用随机抽样的方法，较真切的模拟粒子输运的过程，反映了统计涨落的规律。

数学建模中十大算法讲义

这道题是很典型的用神经网络的分类问题，只需用感知器神经网络便能完成此分类工作，我们用前 40 组数据对网络进行训练，再用训练号的网络来计算后 20 组数据，便能得到分类的结果。详细的程序可参见本讲义附带的 Matlab 程序。 5．神经网络的程序设计
该讲义附带了如下程序资源： Matlab 神经网络工具箱函数简介癌症判断题（2001 年北京大学数学建模竞赛）的 Matlab 程序
神经网络按照网络结构和激发函数的不同可分为许多种，我们在此只是对感知器和 BP 网络进行简介。感知器：
最早也是最简单的一种神经网络，它的神经元激发函数为阶跃函数，其神经元结构如下图：
感知器主要用于分类。 BP 网络：
应用得最为广泛，最为重要的一种神经网络。这种网络一般有多层，网络结构如下：
BP 网络的激发函数一般采用 S 型函数，如正切或对数函数，其神经元结构如下：
=
0.80（其中分母
100
为
10
个教授都给最高分时的总
分）相应的x2对x1的优先选择比为 r21 = 1 − r12 = 1 − 0.8 = 0.2 。利用上面的方法便
可以得到下表：一等二等
10
8
x1-> x2 3
4
x1-> x3 1
5
x1-> x4 2
5
x1-> x5 6
2
x1-> x6 3
1
采取等级制，各等级的分数如下：
评分标准一等二等三等四等五等六等
分数
10
8
6
4
3
1
将参加评选的同学进行两两比较评分，例如x1→x2（以先评价的x2为基准，后评价的x1为对象进行相对比较评分）。比如 10 人所给相加的总分为 80 分，则学生x1对

894编号数学建模十大经典算法（__数学建模必备资料）

建模十大经典算法1、蒙特卡罗算法。

该算法又称随机性模拟算法，是通过计算机仿真来解决问题的算法，同时通过模拟可以来检验自己模型的正确性。

2、数据拟合、参数估计、插值等数据处理算法。

比赛中通常会遇到大量的数据需要处理，而处理数据的关键就在于这些算法，通常使用Matlab作为工具。

3、线性规划、整数规划、多元规划、二次规划等规划类问题。

建模竞赛大多数问题属于最优化问题，很多时候这些问题可以用数学规划算法来描述，通常使用Lindo、Lingo、MATLAB软件实现。

4、图论算法。

这类算法可以分为很多种，包括最短路、网络流、二分图等算法，涉及到图论的问题可以用这些方法解决，需要认真准备。

5、动态规划、回溯搜索、分治算法、分支定界等计算机算法。

这些算法是算法设计中比较常用的方法，很多场合可以用到竞赛中。

6、最优化理论的三大非经典算法：模拟退火法、神经网络、遗传算法。

这些问题是用来解决一些较困难的最优化问题的算法，对于有些问题非常有帮助，但是算法的实现比较困难，需慎重使用。

7、网格算法和穷举法。

网格算法和穷举法都是暴力搜索最优点的算法，在很多竞赛题中有应用，当重点讨论模型本身而轻视算法的时候，可以使用这种暴力方案，最好使用一些高级语言作为编程工具。

8、一些连续离散化方法。

很多问题都是实际来的，数据可以是连续的，而计算机只认的是离散的数据，因此将其离散化后进行差分代替微分、求和代替积分等思想是非常重要的。

9、数值分析算法。

如果在比赛中采用高级语言进行编程的话，那一些数值分析中常用的算法比如方程组求解、矩阵运算、函数积分等算法就需要额外编写库函数进行调用。

10、图象处理算法。

赛题中有一类问题与图形有关，即使与图形无关，论文中也应该要不乏图片的，这些图形如何展示以及如何处理就是需要解决的问题，通常使用Matlab进行处理。

历年全国数学建模试题及解法赛题解法93A非线性交调的频率设计拟合、规划93B足球队排名图论、层次分析、整数规划94A逢山开路图论、插值、动态规划94B锁具装箱问题图论、组合数学95A飞行管理问题非线性规划、线性规划95B天车与冶炼炉的作业调度动态规划、排队论、图论96A最优捕鱼策略微分方程、优化96B节水洗衣机非线性规划97A零件的参数设计非线性规划97B截断切割的最优排列随机模拟、图论98A一类投资组合问题多目标优化、非线性规划98B灾情巡视的最佳路线图论、组合优化99A自动化车床管理随机优化、计算机模拟99B钻井布局0-1规划、图论00A DNA序列分类模式识别、Fisher判别、人工神经网络00B钢管订购和运输组合优化、运输问题01A血管三维重建曲线拟合、曲面重建01B 公交车调度问题多目标规划02A车灯线光源的优化非线性规划02B彩票问题单目标决策03A SARS的传播微分方程、差分方程03B 露天矿生产的车辆安排整数规划、运输问题04A奥运会临时超市网点设计统计分析、数据处理、优化04B电力市场的输电阻塞管理数据拟合、优化05A长江水质的评价和预测预测评价、数据处理05B DVD在线租赁随机规划、整数规划06A 出版资源配置06B 艾滋病疗法的评价及疗效的预测 07A 中国人口增长预测 07B 乘公交，看奥运多目标规划数据处理图论 08A 数码相机定位 08B 高等教育学费标准探讨09A 制动器试验台的控制方法分析 09B 眼科病床的合理安排动态规划 10A 10B赛题发展的特点：1.对选手的计算机能力提出了更高的要求：赛题的解决依赖计算机，题目的数据较多，手工计算不能完成，如03B ，某些问题需要使用计算机软件，01A 。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

假如把1 6硬币的例子看成一个大的问题。第一步，把这一问题分成两个小问题。随机选择8个硬币作为第一组称为A组，剩下的8个硬币作为第二组称为B组。这样，就把1 6个硬币的问题分成两个8硬币的问题来解决。第二步，判断A和B组中是否有伪币。可以利用仪器来比较A组硬币和B组硬币的重量。假如两组硬币重量相等，则可以判断伪币不存在。假如两组硬币重量不相等，则存在伪币，并且可以判断它位于较轻的那一组硬币中。最后，在第三步中，用第二步的结果得出原先1 6个硬币问题的答案。若仅仅判断硬币是否存在，则第三步非常简单。无论A组还是B组中有伪币，都可以推断这1 6个硬币中存在伪币。因此，仅仅通过一次重量的比较，就可以判断伪币是否存在。
分治算法
君主和殖民者们所成功运用的分而治之策略也可以运用到高效率的计算机算法的设计过程中。利用这一策略可以解决如下问题：最小最大问题、矩阵乘法、残缺棋盘、排序、选择和计算一个几何问题——找出二维空间中距离最近的两个点。
算法思想
分而治之方法与软件设计的模块化方法非常相似。为了解决一个大的问题，可以： 1) 把它分成两个或多个更小的问题； 2) 分别解决每个小问题； 3) 把各小问题的解答组合起来，即可得到原问题的解答。小问题通常与原问题相似，可以递归地使用分而治之策略来解决。
算法思想
分枝定界（branch and bound）是另一种系统地搜索解空间的方法，它与回溯法的主要区别在于对E-节点的扩充方式。每个活节点有且仅有一次机会变成E节点。当一个节点变为E-节点时，则生成从该节点移动一步即可到达的所有新节点。在生成的节点中，抛弃那些不可能导出（最优）可行解的节点，其余节点加入活节点表，然后从表中选择一个节点作为下一个 E-节点。从活节点表中取出所选择的节点并进行扩充，直到找到解或活动表为空，扩充过程才结束。
6、模拟退火法、神经网络、遗传算法
模拟退火法（SLeabharlann mulated Annealing）是 Kirkpatrick等人在一九八三年提出并成功地应用在组合最佳化問題中，它是蒙特卡罗演算法的推广。人工神经网络的基本结构: 递归网络和前馈网络人工神经网络的典型模型有:自适应谐振理论 (ART)、 Kohonen 网络、反向传播(BP)网络、 Hopfield网
数学建模竞赛中应当掌握的十类算法
• 蒙特卡罗算法 • 数据处理算法 • 数学规划算法 • 图论算法 • 动态规划、回溯搜索、分治算法、分支定
界 • 三大非经典算法 • 网格算法和穷举法 • 连续离散化方法 • 数值分析算法 • 图象处理算法
1、蒙特卡罗算法
该算法又称随机性模拟算法，是通过计算机仿真来解决问题的算法，同时可以通过模拟可以来检验自己模型的正确性，是比赛时必用的方法
5、动态规划、回溯搜索、分治算法、分支定界
这些算法是算法设计中比较常用的方法，很多场合可以用到竞赛中
动态规划
它建立在最优原则的基础上。采用动态规划方法，可以优雅而高效地解决许多用贪婪算法或分而治之算法无法解决的问题。动态规划方法在解决背包问题、图象压缩、矩阵乘法链、最短路径、无交叉子集和元件折叠等方面的有很大作用。
7、网格算法和穷举法
网格算法和穷举法都是暴力搜索最优点的算法，在很多竞赛题中有应用，当重点讨论模型本身而轻视算法的时候，可以使用这种暴力方案，最好使用一些高级语言作为编程工具
2、数据拟合、参数估计、插值等数据处理算法
数据拟和: 从给出的一大堆数据中找出规律，即设法构造一条曲线(拟和曲线)反映数据点总的趋势，以消除其局部波动。
参数估计：对给定的统计问题，在建立了统计模型以后，我们的任务就是依据样本对未知总体进行各种推断，参数估计是统计推断的重要内容之一。包括点估计方法、频率替换法、矩法、极大似然估计法
插值法是函数逼近的一种重要方法，包括多项式插值、分段插值和三角插值
3、数学规划算法
线性规划、整数规划、多元规划、二次规划等规划类问题（建模竞赛大多数问题属于最优化问题，很多时候这些问题可以用数学规划算法来描述，通常使用Lindo、 Lingo软件实现）
4、图论算法
这类算法可以分为很多种，包括最短路、网络流、二分图等算法，涉及到图论的问题可以用这些方法解决，需要认真准备
考虑平面上的一个边长为1的正方形及其内部的一个形状不规则的“图形”，如何求出这个“图形”的面积呢？Monte Carlo方法是这样一种“随机化”的方法：向该正方形“随机地”投掷N个点落于“图形”内，则该“图形”的面积近似为M/N。
另一类形式与Monte Carlo方法相似，但理论基础不同的方法—“拟蒙特卡罗方法” (Quasi-Monte Carlo方法)—近年来也获得迅速发展。我国数学家华罗庚、王元提出的“华—王”方法即是其中的一例。这种方法的基本思想是“用确定性的超均匀分布序列(数学上称为Low Discrepancy Sequences)代替Monte Carlo方法中的随机数序列。对某些问题该方法的实际速度一般可比Monte Carlo方法提出高数百倍，并可计算精确度。
蒙特卡罗(Monte Carlo)方法，或称计算机随机模拟方法，是一种基于“随机数”的计算方法。这一方法源于美国在第一次世界大战进研制原子弹的“曼哈顿计划”。该计划的主持人之一、数学家冯·诺伊曼用驰名世界的赌城—摩纳哥的Monte Carlo— 来命名这种方法，为它蒙上了一层神秘色彩。
• 具体实现的matlab代码： • ------------------------------------------------------------------------------------------------
--• function val = ballvol(n, m) • % BALLVOL Compute volume of unit ball in R^n •% • % Computes the volume of the n-dimensional unit ball • % using monte-carlo method. • % usage: val = BallVol(n, m) • % where: n = dimension • % m = number of realisations • % If the second argument is omitted, 1e4 is taken as default for m. • % (c) 1998, Rolf Krause, krause@math.fu-berlin.de • M = 1e4; • error = 0; • if(nargin <1 | nargin > 2), error('wrong number of arguments'); end • if nargin == 2, M = m; end • R = rand(n, M); • in = 0; • for i=1:M • if(norm(R(:,i),2) <= 1.0), in = in+1; end • end
算法思想
和贪婪算法一样，在动态规划中，可将一个问题的解决方案视为一系列决策的结果。不同的是，在贪婪算法中，每采用一次贪婪准则便做出一个不可撤回的决策，而在动态规划中，还要考察每个最优决策序列中是否包含一个最优子序列。
寻找问题的解的一种可靠的方法是首先列出所有候选解，然后依次检查每一个，在检查完所有或部分候选解后，即可找到所需要的解。理论上，当候选解数量有限并且通过检查所有或部分候选解能够得到所需解时，上述方法是可行的。不过，在实际应用中，很少使用这种方法，因为候选解的数量通常都非常大（比如指数级，甚至是大数阶乘），即便采用最快的计算机也只能解决规模很小的问题。对候选解进行系统检查的方法有多种，其中回溯和分枝定界法是比较常用的两种方法。按照这两种方法对候选解进行系统检查通常会使问题的求解时间大大减少（无论对于最坏情形还是对于一般情形）。事实上，这些方法可以使我们避免对很大的候选解集合进行检查，同时能够保证算法运行结束时可以找到所需要的解。因此，这些方法通常能够用来求解规模很大的问题。
现在假设需要识别出这一伪币。把两个或三个硬币的情况作为不可再分的小问题。注意如果只有一个硬币，那么不能判断出它是否就是伪币。在一个小问题中，通过将一个硬币分别与其他两个硬币比较，最多比较两次就可以找到伪币。这样，1 6硬币的问题就被分为两个8硬币（A组和B组）的问题。通过比较这两组硬币的重量，可以判断伪币是否存在。如果没有伪币，则算法终止。否则，继续划分这两组硬币来寻找伪币。假设B是轻的那一组，因此再把它分成两组，每组有4个硬币。称其中一组为B1，另一组为B2。比较这两组，肯定有一组轻一些。如果B1轻，则伪币在B1中，再将B1又分成两组，每组有两个硬币，称其中一组为B1a，另一组为 B1b。比较这两组，可以得到一个较轻的组。由于这个组只有两个硬币，因此不必再细分。比较组中两个硬币的重量，可以立即知道哪一个硬币轻一些。较轻的硬币就是所要找的伪币。
例2-1 [找出伪币] 给你一个装有1 6个硬币的袋子。1 6个硬币中有一个是伪造的，并且那个伪造的硬币比真的硬币要轻一些。你的任务是找出这个伪造的硬币。为了帮助你完成这一任务，将提供一台可用来比较两组硬币重量的仪器，利用这台仪器，可以知道两组硬币的重量是否相同。
比较硬币1与硬币2的重量。假如硬币1比硬币 2轻，则硬币1是伪造的；假如硬币2比硬币1 轻，则硬币2是伪造的。这样就完成了任务。假如两硬币重量相等，则比较硬币3和硬币4。同样，假如有一个硬币轻一些，则寻找伪币的任务完成。假如两硬币重量相等，则继续比较硬币5和硬币6。按照这种方式，可以最多通过8次比较来判断伪币的存在并找出这一伪币。
分枝定界
类似于回溯法，分枝定界法在搜索解空间时，也经常使用树形结构来组织解空间。然而与回溯法不同的是，回溯算法使用深度优先方法搜索树结构，而分枝定界一般用宽度优先或最小耗费方法来搜索这些树。本章与第1 6章所考察的应用完全相同，因此，可以很容易比较回溯法与分枝定界法的异同。相对而言，分枝定界算法的解空间比回溯法大得多，因此当内存容量有限时，回溯法成功的可能性更大