蚁群算法C++
==== 蚁群算法C++代码(本人修改了，保证可以运行)====
123.234.206.* 1楼
// ANT.cpp : 定义控制台应用程序的入口点。
//
//代码来源于网上，网上的代码错误太多，根本就没法运行。
//我修改了一下。
//修改内容为：加入了比较详细的注释，修改了原来程序中的很多错
误。
//城市坐标数据直接写在代码里面，使用的是eil51.tsp中的数据
//Made by wugsh @ 2009.07.29
//通讯地址：guangsheng.wu@https://www.wendangku.net/doc/858260432.html,
#include "stdafx.h"
#include
#include
using namespace std;
const int N_ANT_COUNT = 34; //蚂蚁数量，一般取值原则为：城市数
量 / 蚂蚁数量 = 1.5左右
const int N_CITY_COUNT = 51; //城市数量
const int N_IT_COUNT = 5000; //迭代次数，就是搜索次数
const double DB_Q=100; //总的信息素
const double DB_ALPHA=1; //信息素重要程度
const double DB_BETA=3; //这个数越大，则蚂蚁往信息素大的地方走
的概率就越大
const double DB_ROU=0.5; //环境信息素挥发速度
int besttour[N_CITY_COUNT];//最佳路径列表
//获得指定范围内的一个随机数
double rnd(int low,double uper)
{
double p=(rand()/(double)RAND_MAX)*((uper)-(low))+(low);
return (p);
};
//获得指定上限范围内的一个随机数
int rnd(int uper)
{
return (rand()%uper);
};
顶
?2009-07-29 10:04
?回复
123.234.206.* 2楼
//tsp地图信息，包含了信息素，城市距离，和信息素变化矩阵
class GInfo
{
public:
double m_dDeltTrial[N_CITY_COUNT][N_CITY_COUNT]; //临时保存
信息素，更新环境信息素的时候使用，每只蚂蚁周游完各个城市后开
始计算
double m_dTrial[N_CITY_COUNT][N_CITY_COUNT]; //城市间的信
息素，就是环境信息素
double distance[N_CITY_COUNT][N_CITY_COUNT]; //城市间距离
};
GInfo Map;
//定义蚂蚁类
class ant
{
private:
int ChooseNextCity(); //选择下一个城市
double prob[N_CITY_COUNT]; //临时变量数组，选择下一个城市的时候，保存各个城市被选中的概率值
int m_nCityCount; //记录蚂蚁已经走过的城市数目
int AllowedCity[N_CITY_COUNT];//没有走过的城市，数组索引对应城市编号
public:
double m_dLength;
double m_dShortest;
int tabu[N_CITY_COUNT]; //记录走过的城市，里面存的是城市的编号，数组索引表示走的顺序。
public:
ant();
void addcity(int city);
void Clear();
void UpdateResult();
void move();
void move2last();
};
//只剩下一个城市没走过时才调用，直接移动到最后一个城市
void ant::move2last()
{
for(int i=0;i { if (AllowedCity[i]==1) { addcity(i); break; } } } //清空数据，蚂蚁周游完各个城市后，要重新开始周游各个城市时调用 void ant::Clear() { m_dLength=0; for(int i=0; i { prob[i]=0; AllowedCity[i]=1; } i=tabu[N_CITY_COUNT-1]; //用最后一个城市作为出发城市 m_nCityCount=0; addcity(i); } ?2009-07-29 10:04 ?回复 ?4k_wugsh ?31位粉丝? 3楼 //初始化 ant::ant() { m_dLength=m_dShortest=0; m_nCityCount=0; for(int i=0;i { AllowedCity[i]=1; prob[i]=0; } } //增加一个城市到走过的城市数组中，并改变没走过的城市数组中的标志 void ant::addcity(int city) { //add city to tabu; tabu[m_nCityCount]=city; m_nCityCount++; AllowedCity[city]=0; } int ant::ChooseNextCity() { //Update the probability of path selection //select a path from tabu[m_nCityCount-1] to next int j=10000; double temp=0.0; int curCity=tabu[m_nCityCount-1]; //当前走到那个城市了 //先计算当前城市和没有走过的城市，两两之间的信息素的总和 for (int i=0;i { if (AllowedCity[i] == 1) { temp=temp+pow((1.0/Map.distance[curCity][i]),DB_BETA)*pow((Map. m_dTrial[curCity][i]),DB_ALPHA); } } //计算没有走过的城市被选中的概率 double sel=0; for (i=0;i { if (AllowedCity[i] == 1) { prob[i]=pow((1.0/Map.distance[curCity][i]),DB_BETA)*pow((Map.m_d Trial[curCity][i]),DB_ALPHA)/temp; sel+=prob[i]; } else { prob[i]=0; } } //下面的操作实际上就是遗传算法中的轮盘选择 double mRate=rnd(0,sel); double mSelect=0; for ( i=0;i { if (AllowedCity[i] == 1) { mSelect+=prob[i] ; } if (mSelect>=mRate) { j=i; break; } } //这种情况只有在temp=0.0的时候才会出现 if (j == 10000) { for (i=0;i { if (AllowedCity[i] == 1) { j=i; break; } } } return j; } ?2009-07-29 10:09 ?回复 ?4k_wugsh ?31位粉丝? 4楼 //计算周游完城市后，走过的路径长度 void ant::UpdateResult() { // Update the length of tour for(int i=0;i { m_dLength+=Map.distance[tabu[i]][tabu[i+1]]; } m_dLength+=Map.distance[tabu[N_CITY_COUNT-1]][tabu[0]]; //最后城市和开始城市间的距离 } //移动到下一个城市 void ant::move() { //the ant move to next town and add town ID to tabu. int n=ChooseNextCity(); addcity(n); } class project { public: double m_dLength; ant ants[N_ANT_COUNT]; public: project(); void UpdateTrial(); void initmap(); void GetAnt(); void StartSearch(); }; ?2009-07-29 10:10 ?回复 ?4k_wugsh ?31位粉丝? 5楼 //更新环境信息素 //这里采用的是 ANT-CYCLE 模式，即每只蚂蚁周游完城市后才更新//还有其他方式为蚂蚁每走一个城市就更新一次，经过试验表明，周游完后才更新比较好 void project::UpdateTrial() { //calculate the changes of trial information int m=0; int n=0; for(int i=0;i { for (int j=0;j m=ants[i].tabu[j]; n =ants[i].tabu[j+1]; Map.m_dDeltTrial[m][n]+=DB_Q/ants[i].m_dLength; Map.m_dDeltTrial[n][m]+=DB_Q/ants[i].m_dLength; } //最后城市到开始城市间的信息素 m=ants[i].tabu[N_CITY_COUNT-1]; n =ants[i].tabu[0]; Map.m_dDeltTrial[m][n]+=DB_Q/ants[i].m_dLength; Map.m_dDeltTrial[n][m]+=DB_Q/ants[i].m_dLength; } //最新的环境信息素 = 消失掉的信息素 + 新留下的信息素 for (int i=0;i { for (int j=0;j { Map.m_dTrial[i][j]=(DB_ROU*Map.m_dTrial[i][j]+Map.m_dDeltTrial[i] [j] ); Map.m_dDeltTrial[i][j]=0; } } } //初始化 void project::initmap() { for(int i=0;i { for (int j=0;j { Map.m_dTrial[i][j]=1; Map.m_dDeltTrial[i][j]=0; } } } project::project() //initial map initmap(); m_dLength=10e9; struct city { int num; int x; int y; } cc[N_CITY_COUNT]; //城市坐标数据来自国际通用的数据 eil51.tsp int x_Ary[51]= { 37,49,52,20,40,21,17,31,52,51, 42,31,5,12,36,52,27,17,13,57, 62,42,16,8,7,27,30,43,58,58, 37,38,46,61,62,63,32,45,59,5, 10,21,5,30,39,32,25,25,48,56, 30 }; int y_Ary[51]= { 52,49,64,26,30,47,63,62,33,21, 41,32,25,42,16,41,23,33,13,58, 42,57,57,52,38,68,48,67,48,27, 69,46,10,33,63,69,22,35,15,6, 17,10,64,15,10,39,32,55,28,37, 40 }; for (int i=0;i { cc[i].x=x_Ary[i]; cc[i].y=y_Ary[i]; cc[i].num=i; } //计算两两城市间距离，需要进行四舍五入取整 //eil51.tsp的最短路径426，是按四舍五入取整后的距离算出来的。 for(int i=0;i { for (int j=0;j { Map.distance[i][j]=(int)(sqrt(pow((cc[i].x-cc[j].x),2)+pow((cc[i].y-cc[j]. y),2))+0.5); } } } ?2009-07-29 10:11 ?回复 ?4k_wugsh ?31位粉丝? 6楼 void project::GetAnt() { //初始化随机种子 srand((unsigned)time(NULL)); //为每只蚂蚁随机分配一个出发城市 int city=0; for (int i=0;i { city=rnd(N_CITY_COUNT); ants[i].addcity(city); } } void project::StartSearch() { //begin to find best solution int max=0;//every ant tours times double temp; int temptour[N_CITY_COUNT]; double dbMin=0.0; while (max < N_IT_COUNT) { dbMin=100000000.0; //本次叠迭中的最小路径长度 for(int j=0;j { for (int i=0;i { ants[j].move(); } } for(int j=0;j { ants[j].move2last(); ants[j].UpdateResult(); //计算路径总长度 } //find out the best solution of the step and put it into temp temp=ants[0].m_dLength; for (int t=0;t { temptour[t]=ants[0].tabu[t]; } for(int j=0;j { if (temp>ants[j].m_dLength) temp=ants[j].m_dLength; for (int t=0;t { temptour[t]=ants[j].tabu[t]; } } if (dbMin>ants[j].m_dLength) { dbMin=ants[j].m_dLength; } } if (temp { m_dLength=temp; for (int t=0;t { besttour[t]=temptour[t]; } } printf("%d : %.0f\n",max,m_dLength); UpdateTrial(); //全部蚂蚁遍历各个城市后，更新环境信息素 for(int j=0;j { ants[j].Clear(); } max++; } printf("The shortest toure is : %f\n",m_dLength); for (int t=0;t printf(" %d ",besttour[t]); } } //主程序入口 int main() { project TSP; TSP.GetAnt(); TSP.StartSearch(); getchar(); return 0; } // ANT.cpp : 定义控制台应用程序的入口点。 // //代码来源于网上，网上的代码错误太多，根本就没法运行。 //我修改了一下。 //修改内容为：加入了比较详细的注释，修改了原来程序中的很多错误。 //城市坐标数据直接写在代码里面，使用的是eil51.tsp中的数据 //Made by wugsh @ 2009.07.29 //通讯地址：guangsheng.wu@https://www.wendangku.net/doc/858260432.html, #include "stdafx.h" #include #include using namespace std; const int N_ANT_COUNT = 34; //蚂蚁数量，一般取值原则为：城市数量/ 蚂蚁数量= 1.5左右 const int N_CITY_COUNT = 51; //城市数量 const int N_IT_COUNT = 5000; //迭代次数，就是搜索次数 const double DB_Q=100; //总的信息素 const double DB_ALPHA=1; //信息素重要程度 const double DB_BETA=3; //这个数越大，则蚂蚁往信息素大的地方走的概率就越大 const double DB_ROU=0.5; //环境信息素挥发速度 int besttour[N_CITY_COUNT];//最佳路径列表 //获得指定范围内的一个随机数 double rnd(int low,double uper) { double p=(rand()/(double)RAND_MAX)*((uper)-(low))+(low); return (p); }; //获得指定上限范围内的一个随机数 int rnd(int uper) { return (rand()%uper); }; //tsp地图信息，包含了信息素，城市距离，和信息素变化矩阵 class GInfo { public: double m_dDeltTrial[N_CITY_COUNT][N_CITY_COUNT]; //临时保存信息素，更新环境信息素的时候使用，每只蚂蚁周游完各个城市后开始计算 double m_dTrial[N_CITY_COUNT][N_CITY_COUNT]; //城市间的信息素，就是环境信息素 double distance[N_CITY_COUNT][N_CITY_COUNT]; //城市间距离 }; GInfo Map; //定义蚂蚁类 class ant { private: int ChooseNextCity(); //选择下一个城市 double prob[N_CITY_COUNT]; //临时变量数组，选择下一个城市的时候，保存各个城市被选中的概率值 int m_nCityCount; //记录蚂蚁已经走过的城市数目 int AllowedCity[N_CITY_COUNT];//没有走过的城市，数组索引对应城市编号 public: double m_dLength; double m_dShortest; int tabu[N_CITY_COUNT]; //记录走过的城市，里面存的是城市的编号，数组索引表示走的顺序。 public: ant(); void addcity(int city); void Clear(); void UpdateResult(); void move(); void move2last(); }; //只剩下一个城市没走过时才调用，直接移动到最后一个城市 void ant::move2last() { for(int i=0;i { if (AllowedCity[i]==1) { addcity(i); break; } } } //清空数据，蚂蚁周游完各个城市后，要重新开始周游各个城市时调用 void ant::Clear() { m_dLength=0; for(int i=0; i { prob[i]=0; AllowedCity[i]=1; } i=tabu[N_CITY_COUNT-1]; //用最后一个城市作为出发城市 m_nCityCount=0; addcity(i); } //初始化 ant::ant() { m_dLength=m_dShortest=0; m_nCityCount=0; for(int i=0;i { AllowedCity[i]=1; prob[i]=0; } } //增加一个城市到走过的城市数组中，并改变没走过的城市数组中的标志void ant::addcity(int city) { //add city to tabu; tabu[m_nCityCount]=city; m_nCityCount++; AllowedCity[city]=0; } int ant::ChooseNextCity() { //Update the probability of path selection //select a path from tabu[m_nCityCount-1] to next int j=10000; double temp=0.0; int curCity=tabu[m_nCityCount-1]; //当前走到那个城市了 //先计算当前城市和没有走过的城市，两两之间的信息素的总和 for (int i=0;i { if (AllowedCity[i] == 1) { temp=temp+pow((1.0/Map.distance[curCity][i]),DB_BETA)*pow((Map.m_dTrial[curCity][i]),D B_ALPHA); } } //计算没有走过的城市被选中的概率 double sel=0; for (i=0;i { if (AllowedCity[i] == 1) { prob[i]=pow((1.0/Map.distance[curCity][i]),DB_BETA)*pow((Map.m_dTrial[curCity][i]),DB_A LPHA)/temp; sel+=prob[i]; } else { prob[i]=0; } } //下面的操作实际上就是遗传算法中的轮盘选择 double mRate=rnd(0,sel); double mSelect=0; for ( i=0;i { if (AllowedCity[i] == 1) { mSelect+=prob[i] ; } if (mSelect>=mRate) { j=i; break; } } 《数据结构与算法》期末复习题 一、选择题。 1．在数据结构中，从逻辑上可以把数据结构分为 C 。 A．动态结构和静态结构B．紧凑结构和非紧凑结构 C．线性结构和非线性结构D．内部结构和外部结构 2．数据结构在计算机内存中的表示是指 A 。 A．数据的存储结构B．数据结构C．数据的逻辑结构D．数据元素之间的关系 3．在数据结构中，与所使用的计算机无关的是数据的 A 结构。 A．逻辑B．存储C．逻辑和存储D．物理 4．在存储数据时，通常不仅要存储各数据元素的值，而且还要存储 C 。 A．数据的处理方法B．数据元素的类型 C．数据元素之间的关系D．数据的存储方法 5．在决定选取何种存储结构时，一般不考虑 A 。 A．各结点的值如何B．结点个数的多少 C．对数据有哪些运算D．所用的编程语言实现这种结构是否方便。 6．以下说法正确的是 D 。 A．数据项是数据的基本单位 B．数据元素是数据的最小单位 C．数据结构是带结构的数据项的集合 D．一些表面上很不相同的数据可以有相同的逻辑结构 7．算法分析的目的是 C ，算法分析的两个主要方面是 A 。 （1）A．找出数据结构的合理性B．研究算法中的输入和输出的关系C．分析算法的效率以求改进C．分析算法的易读性和文档性 （2）A．空间复杂度和时间复杂度B．正确性和简明性 C．可读性和文档性D．数据复杂性和程序复杂性 8．下面程序段的时间复杂度是O(n2) 。 s =0; for( I =0; i 基于蚁群算法的机器人路径规划MATLAB源代码 基本思路是，使用离散化网格对带有障碍物的地图环境建模，将地图环境转化为邻接矩阵，最后使用蚁群算法寻找最短路径。 function [ROUTES,PL,Tau]=ACASPS(G,Tau,K,M,S,E,Alpha,Beta,Rho,Q) %% --------------------------------------------------------------- % ACASP.m % 基于蚁群算法的机器人路径规划 % GreenSim团队——专业级算法设计&代写程序 % 欢迎访问GreenSim团队主页→https://www.wendangku.net/doc/858260432.html,/greensim %% --------------------------------------------------------------- % 输入参数列表 % G 地形图为01矩阵，如果为1表示障碍物 % Tau 初始信息素矩阵（认为前面的觅食活动中有残留的信息素） % K 迭代次数（指蚂蚁出动多少波） % M 蚂蚁个数（每一波蚂蚁有多少个） % S 起始点（最短路径的起始点） % E 终止点（最短路径的目的点） % Alpha 表征信息素重要程度的参数 % Beta 表征启发式因子重要程度的参数 % Rho 信息素蒸发系数 % Q 信息素增加强度系数 % % 输出参数列表 % ROUTES 每一代的每一只蚂蚁的爬行路线 % PL 每一代的每一只蚂蚁的爬行路线长度 % Tau 输出动态修正过的信息素 %% --------------------变量初始化---------------------------------- %load D=G2D(G); N=size(D,1);%N表示问题的规模（象素个数） MM=size(G,1); a=1;%小方格象素的边长 Ex=a*(mod(E,MM)-0.5);%终止点横坐标 if Ex==-0.5 Ex=MM-0.5; end Ey=a*(MM+0.5-ceil(E/MM));%终止点纵坐标 Eta=zeros(1,N);%启发式信息，取为至目标点的直线距离的倒数 %下面构造启发式信息矩阵 for i=1:N 排序问题P11 #include if (a[j] < a[min]) { min = j; } } if (min != i) { t = a[i]; a[i] = a[min]; a[min] = t; } } } int BinarySearch(int x) { int left=0; int right=n-1; while(left<=right){ int middle=(left+right)/2; if (x==a[middle]) return middle; if (x>a[middle]) left=middle+1; else right=middle-1; } return -1; } void main() { cout<<"输入数字的个数："< 一、基本算法 1．交换（两量交换借助第三者） 例1、任意读入两个整数，将二者的值交换后输出。 main() {int a,b,t; scanf("%d%d",&a,&b); printf("%d,%d\n",a,b); t=a; a=b; b=t; printf("%d,%d\n",a,b);} 【解析】程序中加粗部分为算法的核心，如同交换两个杯子里的饮料，必须借助第三个空杯子。 假设输入的值分别为3、7，则第一行输出为3，7；第二行输出为7，3。 其中t为中间变量，起到“空杯子”的作用。 注意：三句赋值语句赋值号左右的各量之间的关系！ 【应用】 例2、任意读入三个整数，然后按从小到大的顺序输出。 main() {int a,b,c,t; scanf("%d%d%d",&a,&b,&c); /*以下两个if语句使得a中存放的数最小*/ if(a>b){ t=a; a=b; b=t; } if(a>c){ t=a; a=c; c=t; } /*以下if语句使得b中存放的数次小*/ if(b>c) { t=b; b=c; c=t; } printf("%d,%d,%d\n",a,b,c);} 2．累加 累加算法的要领是形如“s=s+A”的累加式，此式必须出现在循环中才能被反复执行，从而实现累加功能。“A”通常是有规律变化的表达式，s在进入循环前必须获得合适的初值，通常为0。例1、求1+2+3+……+100的和。 main() {int i,s; s=0; i=1; while(i<=100) {s=s+i; /*累加式*/ i=i+1; /*特殊的累加式*/ } printf("1+2+3+...+100=%d\n",s);} 【解析】程序中加粗部分为累加式的典型形式，赋值号左右都出现的变量称为累加器，其中“i = i + 1”为特殊的累加式，每次累加的值为1，这样的累加器又称为计数器。 MATLAB实现基于蚁群算法的机器人路径规划 1、问题描述 移动机器人路径规划是机器人学的一个重要研究领域。它要求机器人依据某个或某些优化原则(如最小能量消耗，最短行走路线，最短行走时间等)，在其工作空间中找到一条从起始状态到目标状态的能避开障碍物的最优路径。机器人路径规划问题可以建模为一个有约束的优化问题，都要完成路径规划、定位和避障等任务。 2 算法理论 蚁群算法（Ant Colony Algorithm，ACA），最初是由意大利学者Dorigo M. 博士于1991 年首次提出，其本质是一个复杂的智能系统，且具有较强的鲁棒性，优良的分布式计算机制等优点。该算法经过十多年的发展，已被广大的科学研究人员应用于各种问题的研究，如旅行商问题，二次规划问题，生产调度问题等。但是算法本身性能的评价等算法理论研究方面进展较慢。 Dorigo 提出了精英蚁群模型（EAS），在这一模型中信息素更新按照得到当前最优解的蚂蚁所构造的解来进行，但这样的策略往往使进化变得缓慢，并不能取得较好的效果。次年Dorigo 博士给出改进模型（ACS），文中改进了转移概率模型，并且应用了全局搜索与局部搜索策略，来得进行深度搜索。Stützle 与Hoos给出了最大-最小蚂蚁系统（MAX-MINAS），所谓最大-最小即是为信息素设定上限与下限，设定上限避免搜索陷入局部最优，设定下限鼓励深度搜索。蚂蚁作为一个生物个体其自身的能力是十分有限的，比如蚂蚁个体是没有视觉的，蚂蚁自身体积又是那么渺小，但是由这些能力有限的蚂蚁组成的蚁群却可以做出超越个体蚂蚁能力的超常行为。蚂蚁没有视觉却可以寻觅食物，蚂蚁体积渺小而蚁群却可以搬运比它们个体大十倍甚至百倍的昆虫。这些都说明蚂蚁群体内部的某种机制使得它们具有了群体智能，可以做到蚂蚁个体无法实现的事情。经过生物学家的长时间观察发现，蚂蚁是通过分泌于空间中的信息素进行信息交流，进而实现群体行为的。 下面简要介绍蚁群通过信息素的交流找到最短路径的简化实例。如图2-1 所示，AE 之间有两条路ABCDE 与ABHDE，其中AB，DE，HD，HB 的长度为1，BC，CD 长度为0.5，并且，假设路上信息素浓度为0，且各个蚂蚁行进速度相同，单位时间所走的长度为1，每个单位时间内在走过路径上留下的信息素的量也相同。当t=0时，从A 点，E 点同时各有30 只蚂蚁从该点出发。当t=1，从A 点出发的蚂蚁走到B 点时，由于两条路BH 与BC 上的信息素浓度相同，所以蚂蚁以相同的概率选择BH 与BC，这样就有15 只蚂蚁选择走BH，有15 只蚂蚁选择走BC。同样的从E 点出发的蚂蚁走到D 点，分别有15 只蚂蚁选择DH 和DC。当t=2 时，选择BC 与DC的蚂蚁分别走过了BCD 和DCB，而选择BH 与DH 的蚂蚁都走到了H 点。所有的蚂蚁都在所走过的路上留下了相同浓度的信息素，那么路径BCD 上的信息素的浓度是路径BHD 上信息素浓度的两倍，这样若再次有蚂蚁选择走BC 和BH 时，或选择走DC 与DH 时，都会以较大的概率选择信息素浓度高的一边。这样的过程反复进行下去，最短的路径上走过的蚂蚁较多，留下的信息素也越多，蚁群这样就可以找到一条较短的路。这就是它们群体智能的体现。 蚁群算法就是模拟蚂蚁觅食过程中可以找到最短的路的行为过程设计的一种仿生算法。在用蚁群算法求解组合优化问题时，首先要将组合优化问题表达成与信息素相关的规范形式，然后各个蚂蚁独立地根据局部的信息素进行决策构造解，并根据解的优劣更新周围的信息素，这样的过程反复的进行即可求出组合优化问题的优化解。 归结蚁群算法有如下特点： （1）分布式计算：各个蚂蚁独立地构造解，当有蚂蚁个体构造的解较差时，并不会影响整体的求解结果。这使得算法具有较强的适应性； （2）自组织性：系统学中自组织性就是系统的组织指令是来自系统的内部。同样的蚁 蚁群算法浅析 摘要：介绍了什么是蚁群算法，蚁群算法的种类，对四种不同的蚁群算法进行了分析对比。详细阐述了蚁群算法的基本原理，将其应用于旅行商问题，有效地解决了问题。通过对旅行商问题C++模拟仿真程序的详细分析，更加深刻地理解与掌握了蚁群算法。 关键词：蚁群算法；旅行商问题；信息素；轮盘选择 一、引言 蚁群算法（Ant Colony Optimization, ACO），是一种用来在图中寻找优化路径的算法。它由Marco Dorigo于1992年在他的博士论文中提出，其灵感来源于蚂蚁在寻找食物过程中发现路径的行为。蚁群算法是一种模拟进化算法，初步的研究表明该算法具有许多优良的性质。 蚁群算法成功解决了旅行商问题（Traveling Salesman Problem, TSP）：一个商人要到若干城市推销物品，从一个城市出发要到达其他各城市一次而且最多一次最后又回到第一个城市。寻找一条最短路径，使他从起点的城市到达所有城市一遍，最后回到起点的总路程最短。若把每个城市看成是图上的节点，那么旅行商问题就是在N个节点的完全图上寻找一条花费最少的回路。 最基本的蚁群算法见第二节。目前典型的蚁群算法有随机蚁群算法、排序蚁群算法和最大最小蚁群算法，其中后两种蚁群算法是对前一种的优化。本文将终点介绍随机蚁群算法。 二、基本蚁群算法 （一）算法思想 各个蚂蚁在没有事先告诉他们食物在什么地方的前提下开始寻找食物。当一只找到食物以后，它会向环境释放一种信息素，信息素多的地方显然经过这里的蚂蚁会多，因而会有更多的蚂蚁聚集过来。假设有两条路从窝通向食物，开始的时候，走这两条路的蚂蚁数量同样多（或者较长的路上蚂蚁多，这也无关紧要）。当蚂蚁沿着一条路到达终点以后会马上返回来，这样，短的路蚂蚁来回一次的时间就短，这也意味着重复的频率就快，因而在单位时间里走过的蚂蚁数目就多，洒下的信息素自然也会多，自然会有更多的蚂蚁被吸引过来，从而洒下更多的信息素。因此，越来越多地蚂蚁聚集到较短的路径上来，最短的路径就找到了。 蚁群算法的基本思想如下图表示： 2008-02-18 18:48 【程序1】 题目：有1、2、3、4个数字，能组成多少个互不相同且无重复数字的三位数？都是多少？ 1.程序分析：可填在百位、十位、个位的数字都是1、2、3、4。组成所有的排列后再去 掉不满足条件的排列。 2.程序源代码： main() { int i,j,k; printf("\n"); for(i=1;i<5;i++) ／*以下为三重循环*/ for(j=1;j<5;j++) for (k=1;k<5;k++) { if (i!=k&&i!=j&&j!=k) /*确保i、j、k三位互不相同*/ printf("%d,%d,%d\n",i,j,k); } } ============================================================== 【程序2】 题目：企业发放的奖金根据利润提成。利润(I)低于或等于10万元时，奖金可提10%；利润高 于10万元，低于20万元时，低于10万元的部分按10%提成，高于10万元的部分，可可提 成7.5%；20万到40万之间时，高于20万元的部分，可提成5%；40万到60万之间时高于 40万元的部分，可提成3%；60万到100万之间时，高于60万元的部分，可提成1.5%，高于 100万元时，超过100万元的部分按1%提成，从键盘输入当月利润I，求应发放奖金总数？ 1.程序分析：请利用数轴来分界，定位。注意定义时需把奖金定义成长整型。 2.程序源代码： main() { long int i; int bonus1,bonus2,bonus4,bonus6,bonus10,bonus; scanf("%ld",&i); bonus1=100000*0.1;bonus2=bonus1+100000*0.75; bonus4=bonus2+200000*0.5; bonus6=bonus4+200000*0.3; bonus10=bonus6+400000*0.15; if(i<=100000) 基于蚁群算法的机器人路径规划 说明：基于蚁群算法的机器人路径规划，使用网格离散化的方法对带有障碍物的环境建模，使用邻接矩阵存储该环境，使得问题转化为蚁群算法寻找最短路径。 使用网格离散化的方法对带有障碍物的环境建模，使用邻接矩阵存储该环境，使得问题转化为蚁群算法寻找最短路径。 % ACASP.m % 蚁群算法动态寻路算法 % GreenSim团队原创作品，转载请注明 % Email:greensim@https://www.wendangku.net/doc/858260432.html, %% --------------------------------------------------------------- % 输入参数列表 % G 地形图为01矩阵，如果为1表示障碍物 % Tau 初始信息素矩阵（认为前面的觅食活动中有残留的信息素） % K 迭代次数（指蚂蚁出动多少波） % M 蚂蚁个数（每一波蚂蚁有多少个） % S 起始点（最短路径的起始点） % E 终止点（最短路径的目的点） % Alpha 表征信息素重要程度的参数 % Beta 表征启发式因子重要程度的参数 % Rho 信息素蒸发系数 % Q 信息素增加强度系数 % % 输出参数列表 % ROUTES 每一代的每一只蚂蚁的爬行路线 % PL 每一代的每一只蚂蚁的爬行路线长度 % Tau 输出动态修正过的信息素 %% --------------------变量初始化---------------------------------- %load D=G2D(G); N=size(D,1);%N表示问题的规模（象素个数） MM=size(G,1); a=1;%小方格象素的边长 Ex=a*(mod(E,MM)-0.5);%终止点横坐标 if Ex==-0.5 Ex=MM-0.5; end Ey=a*(MM+0.5-ceil(E/MM));%终止点纵坐标 Eta=zeros(1,N);%启发式信息，取为至目标点的直线距离的倒数 %下面构造启发式信息矩阵 程序算法描述流程图 程序算法描述流程图 算法的方法 递推法 递推是序列计算机中的一种常用算法。它是按照一定的规律来计算序列中的每个项，通常是通过计算机前面的一些项来得出序列中的指定项的值。其思想是把一个复杂的庞大的计算过程转化为简单过程的多次重复，该算法利用了计算机速度快和不知疲倦的机器特点。 递归法 程序调用自身的编程技巧称为递归(recursion)。一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。一般来说，递归需要有边界条件、递归前进段和递归返回段。当边界条件不满足时，递归前进;当边界条件满足时，递归返回。 注意： (1) 递归就是在过程或函数里调用自身; (2) 在使用递归策略时，必须有一个明确的递归结束条件，称为递归出口。 穷举法 穷举法，或称为暴力破解法，其基本思路是：对于要解决的问题，列举出它的所有可能的情况，逐个判断有哪些是符合问题所要求的条件，从而得到问题的解。它也常用于对于密码的破译，即将密码进行逐个推算直到找出真正的密码为止。例如一个 已知是四位并且全部由数字组成的密码，其可能共有10000种组合，因此最多尝试10000次就能找到正确的密码。理论上利用这种方法可以破解任何一种密码，问题只在于如何缩短试误时间。因此有些人运用计算机来增加效率，有些人辅以字典来缩小密码组合的范围。 贪心算法 贪心算法是一种对某些求最优解问题的更简单、更迅速的设计技术。 用贪心法设计算法的特点是一步一步地进行，常以当前情况为基础根据某个优化测度作最优选择，而不考虑各种可能的整体情况，它省去了为找最优解要穷尽所有可能而必须耗费的大量时间，它采用自顶向下,以迭代的方法做出相继的贪心选择,每做一次贪心选择就将所求问题简化为一个规模更小的子问题, 通过每一步贪心选择,可得到问题的一个最优解，虽然每一步上都要保证能获得局部最优解，但由此产生的全局解有时不一定是最优的，所以贪婪法不要回溯。 贪婪算法是一种改进了的分级处理方法，其核心是根据题意选取一种量度标准，然后将这多个输入排成这种量度标准所要求的顺序，按这种顺序一次输入一个量，如果这个输入和当前已构成在这种量度意义下的部分最佳解加在一起不能产生一个可行解，则不把此输入加到这部分解中。这种能够得到某种量度意义下最优解的分级处理方法称为贪婪算法。 对于一个给定的问题，往往可能有好几种量度标准。初看起来，这些量度标准似乎都是可取的，但实际上，用其中的大多数量度标准作贪婪处理所得到该量度意义下的最优解并不是问题的最优解，而是次优解。因此，选择能产生问题最优解的最优量度标准是使用贪婪算法的核心。 一般情况下，要选出最优量度标准并不是一件容易的事，但对某问题能选择出最优量度标准后，用贪婪算法求解则特别有效。 先新建一个主程序M文件ACATSP.m 代码如下: function [R_best,L_best,L_ave,Shortest_Route,Shortest_Length]=ACATSP(C,NC_max,m,Alpha,Beta,Rho,Q) %%================================================== ======================= %% 主要符号说明 %% C n个城市的坐标，n×2的矩阵 %% NC_max 蚁群算法MATLAB程序最大迭代次数 %% m 蚂蚁个数 %% Alpha 表征信息素重要程度的参数 %% Beta 表征启发式因子重要程度的参数 %% Rho 信息素蒸发系数 %% Q 表示蚁群算法MATLAB程序信息素增加强度系数 %% R_best 各代最佳路线 %% L_best 各代最佳路线的长度 %%================================================== ======================= %% 蚁群算法MATLAB程序第一步：变量初始化 n=size(C,1);%n表示问题的规模（城市个数） D=zeros(n,n);%D表示完全图的赋权邻接矩阵 for i=1:n for j=1:n if i~=j D(i,j)=((C(i,1)-C(j,1))^2+(C(i,2)-C(j,2))^2)^0.5; else D(i,j)=eps; % i = j 时不计算，应该为0，但后面的启发因子要取倒数，用eps（浮点相对精度）表示 end D(j,i)=D(i,j); %对称矩阵 end end Eta=1./D; %Eta为启发因子，这里设为距离的倒数 Tau=ones(n,n); %Tau为信息素矩阵 Tabu=zeros(m,n); %存储并记录路径的生成 1.定积分近似计算： /*梯形法*/ double integral(double a,double b,long n) { long i;double s,h,x; h=(b-a)/n; s=h*(f(a)+f(b))/2; x=a; for(i=1;i } 3.素数的判断： /*方法一*/ for (t=1,i=2;i 十大编程算法助程序员走上高手之路 本文为大家梳理阐述了十种高效率的变成算法，熟练掌握的程序员可以借这些方法逐渐发展为高手，那么我们一起来探究一下是哪十种算法有这么神奇的效果。 算法一：快速排序算法 快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序 n 个项目要Ο(n log n)次比较。在最坏状况下则需要Ο(n2)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他Ο(n log n) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。 快速排序使用分治法（Divide and conquer）策略来把一个串行（list）分为两个子串行（sub-lists）。 算法步骤： 1 从数列中挑出一个元素，称为“基准”（pivot）， 2 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。 3 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。 递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会退出，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。 算法二：堆排序算法 堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。 堆排序的平均时间复杂度为Ο(nlogn) 。 算法步骤： 创建一个堆H[0..n-1] 把堆首（最大值）和堆尾互换 3. 把堆的尺寸缩小1，并调用shift_down(0),目的是把新的数组顶端数据调整到相应位置 4. 重复步骤2，直到堆的尺寸为1 （计算智能大作业） 应用蚁群算法求解TSP问题 目录 蚁群算法求解TSP问题 (3) 摘要： (3) 关键词： (3) 一、引言 (3) 二、蚁群算法原理 (4) 三、蚁群算法解决ＴＳＰ问题 (7) 四、解决ｎ个城市的TSP问题的算法步骤 (9) 五、程序实现 (11) 六、蚁群算法优缺点分析及展望 (18) 七、总结 (18) 采用蚁群算法解决TSP问题 摘要：蚁群算法是通过蚂蚁觅食而发展出的一种新的启发算法，该算法已经成功的解决了诸如TSP问题。本文简要学习探讨了蚂蚁算法和TSP问题的基本内容，尝试通过matlab 仿真解决一个实例问题。 关键词：蚁群算法；TSP问题；matlab。 一、引言 TSP（Travelling Salesman Problem）又称货郎担或巡回售货员问题。TSP问题可以描述为：有N个城市，一售货员从起始城市出发，访问所有的城市一次，最后回到起始城市，求最短路径。TSP问题除了具有明显的实际意义外，有许多问题都可以归结为TSP问题。目前针对这一问题已有许多解法，如穷举搜索法（Exhaustive Search Method）, 贪心法（Greedy Method）, 动态规划法（Dynamic Programming Method）分支界定法（Branch-And-Bound），遗传算法（Genetic Agorithm）模拟退火法(simulated annealing),禁忌搜索。本文介绍了一种求解TSP问题的算法—蚁群算法，并通过matlab仿真求解50个城市之间的最短距离，经过仿真试验，证明是一种解决TSP问题有效的方法。 下面的程序是蚁群算法在最短路中的应用，稍加扩展即可应用于机器人路径规划 function [ROUTES,PL,Tau]=ACASP(G,Tau,K,M,S,E,Alpha,Beta,Rho,Q) %% --------------------------------------------------------------- % ACASP.m % 蚁群算法动态寻路算法 % ChengAihua,PLA Information Engineering University,ZhengZhou,China % Email:aihuacheng@https://www.wendangku.net/doc/858260432.html, % All rights reserved %% --------------------------------------------------------------- % 输入参数列表 % G 地形图为01矩阵，如果为1表示障碍物 % Tau 初始信息素矩阵（认为前面的觅食活动中有残留的信息素） % K 迭代次数（指蚂蚁出动多少波） % M 蚂蚁个数（每一波蚂蚁有多少个） % S 起始点（最短路径的起始点） % E 终止点（最短路径的目的点） % Alpha 表征信息素重要程度的参数 % Beta 表征启发式因子重要程度的参数 % Rho 信息素蒸发系数 % Q 信息素增加强度系数 % % 输出参数列表 % ROUTES 每一代的每一只蚂蚁的爬行路线 % PL 每一代的每一只蚂蚁的爬行路线长度 % Tau 输出动态修正过的信息素 %% --------------------变量初始化---------------------------------- %load D=G2D(G); N=size(D,1);%N表示问题的规模（象素个数） MM=size(G,1); a=1;%小方格象素的边长 Ex=a*(mod(E,MM)-0.5);%终止点横坐标 if Ex==-0.5 Ex=MM-0.5; end Ey=a*(MM+0.5-ceil(E/MM));%终止点纵坐标 Eta=zeros(1,N);%启发式信息，取为至目标点的直线距离的倒数 %下面构造启发式信息矩阵 for i=1:N if ix==-0.5 ix=MM-0.5; end C语言常用算法集合 1.定积分近似计算： /*梯形法*/ double integral(double a,double b,long n) { long i;double s,h,x; h=(b-a)/n; s=h*(f(a)+f(b))/2; x=a; for(i=1;i if(n==1||n==2) *s=1; else{ fib(n-1,&f1); fib(n-2,&f2); *s=f1+f2; } } 3.素数的判断： /*方法一*/ for (t=1,i=2;i 用蚁群算法解决TSP 问题 一、引言 蚁群算法是一种受自然界生物行为启发而产生的“自然”算法，产生于对蚂蚁行为的研究。蚁群中的蚂蚁以“信息素”为媒介，间接异步的相互联系。蚂蚁在行动中，会在他们经过的地方留下一些化学物质，称为“信息素”。这些物质能被同一种群众后来的蚂蚁感受到，并作为一种信号影响后者的行动，具体表现在后到的蚂蚁选择有这些物质的路径的可能性比选择没有这些物质的路径的可能性大的多。后者留下的信息素会对原有的信息素进行加强，并循环下去。这样，经过蚂蚁多的路径，后到蚂蚁选择这条路径的可能性就越来越大。由于在一定的时间内，越短的路径会被越多的蚂蚁访问，因而积累的信息素就越多，在下一个时间内被其他的蚂蚁选中的可能性也越大。这个过程会持续到所有的蚂蚁都走到最短的那一条路径为止。 二、关键技术 （1） 解的表达形式 在应用蚁群优化算法时，只需要建立一个虚拟的始终点，相当于蚁群的巢穴和食物所在地，这样一个所经过城市的路径的排列就构成了一个解； （2） 信息素的记忆和更新 在算法开始时，由于从来没有蚂蚁去寻找过路径，因此可以认为是没有任何先验信息，即每条路上的信息相等。客观地将，信息素应该都为0，但是由于在蚁群算法中，信息素决定了蚂蚁选择这条路径的概率，因此可以认 为初始信息素矩阵为：1/(*(1))0ij N N p -?=?? i j i j ≠=其中N 为城市数 当算法运行过程中，每次放出m 支蚂蚁，每只蚂蚁按照信息素选择路径，将其中路径最短的记录下来，对这条最短路进行信息素的加强；而对于其他路径，因为信息素的挥发，信息素浓度将会降低，更新后的信息素矩阵为： 11(1)//(1)/k ij k ij k ij p N p p ρρρ--?-+?=?-?? i j i j →→经过路径不经过路径其中N 为城市数，ρ为挥发系数 （3） 蚁群的规模 在一般应用中，蚁群中蚂蚁的个数m 是固定数，不超过TSP 图的节点数。 MATLAB 实现基于蚁群算法的机器人路径规划 1、问题描述 移动机器人路径规划是机器人学的一个重要研究领域。它要求机器人依据某个或某些优化原则（如最小能量消耗，最短行走路线，最短行走时间等），在其工作空间中找到一条从起 始状态到目标状态的能避开障碍物的最优路径。机器人路径规划问题可以建模为一个有约束的优化问题，都要完成路径规划、定位和避障等任务。 2 算法理论 蚁群算法（Ant Colony Algorithm ，ACA ），最初是由意大利学者Dorigo M. 博士于1991 年首次提出，其本质是一个复杂的智能系统，且具有较强的鲁棒性，优良的分布式计算机制等优点。该算法经过十多年的发展，已被广大的科学研究人员应用于各种问题的研究，如旅行商问题，二次规划问题，生产调度问题等。但是算法本身性能的评价等算法理论研究方面进展较慢。 Dorigo 提出了精英蚁群模型（EAS ），在这一模型中信息素更新按照得到当前最优解的蚂蚁所构造的解来进行，但这样的策略往往使进化变得缓慢，并不能取得较好的效果。次年Dorigo 博士给出改进模型（ACS ），文中改进了转移概率模型，并且应用了全局搜索与局部搜索策略，来得进行深度搜索。 Stützle 与Hoos 给出了最大-最小蚂蚁系统（MAX-MINAS ），所谓最大-最小即是为信息素设定上限与下限，设定上限避免搜索陷入局部最优，设定下限鼓励深度搜索。蚂蚁作为一个生物个体其自身的能力是十分有限的，比如蚂蚁个体是没有视觉的，蚂蚁自身体积又是那么渺小，但是由这些能力有限的蚂蚁组成的蚁群却可以做出超越个体蚂蚁能力的超常行为。蚂蚁没有视觉却可以寻觅食物，蚂蚁体积渺小而蚁群却可以搬运比它们个体大十倍甚至百倍的昆虫。这些都说明蚂蚁群体内部的某种机制使得它们具有了群体智能，可以做到蚂蚁个体无法实现的事情。经过生物学家的长时间观察发现，蚂蚁是通过分泌于空间中的信息素进行信息交流，进而实现群体行为的。 下面简要介绍蚁群通过信息素的交流找到最短路径的简化实例。如图2-1 所示，AE 之间有两条路ABCDE 与ABHDE ，其中AB ，DE，HD，HB 的长度为1，BC，CD 长度为0.5，并且，假设路上信息素浓度为0，且各个蚂蚁行进速度相同，单位时间所走的长度为1，每个单位时间内在走过路径上留下的信息素的量也相同。当t=0 时，从A 点，E 点同时各有30 只蚂蚁从该点出发。当t=1，从A 点出发的蚂蚁走到B 点时，由于两条路BH 与BC 上的信息素浓度相同，所以蚂蚁以相同的概率选择BH 与BC ，这样就有15 只蚂蚁选择走BH，有15 只蚂蚁选择走BC 。同样的从E 点出发的蚂蚁走到D 点，分别有15 只蚂蚁选择DH 和DC。当t=2 时，选择BC 与DC 的蚂蚁分别走过了BCD 和DCB ，而选择BH 与DH 的蚂蚁都走到了H 点。所有的蚂蚁都在所走过的路上留下了相同浓度的信息素，那么路径BCD 上的信息素的浓度是路径BHD 上信息素浓度的两倍，这样若再次有蚂蚁选择走BC 和BH 时，或选择走DC 与DH 时，都会以较大的概率选择信息素浓度高的一边。这样的过程反复进行下去，最短的路径上走过的蚂蚁较多，留下的信息素也越多，蚁群这样就可以找到一条较短的路。这就是它们群体智能的体现。 蚁群算法就是模拟蚂蚁觅食过程中可以找到最短的路的行为过程设计的一种仿生算法。在用蚁群算法求解组合优化问题时，首先要将组合优化问题表达成与信息素相关的规范形式，然后各个蚂蚁独立地根据局部的信息素进行决策构造解，并根据解的优劣更新周围的信息素，这样的过程反复的进行即可求出组合优化问题的优化解。 归结蚁群算法有如下特点： （1）分布式计算：各个蚂蚁独立地构造解，当有蚂蚁个体构造的解较差时，并不会影响整体的求解结果。这使得算法具有较强的适应性； （2）自组织性：系统学中自组织性就是系统的组织指令是来自系统的内部。同样的蚁群算法中的各个蚂蚁的决策是根据系统内部信息素的分布进行的。这使得算法具有较强的鲁棒性； （3）正反馈机制与负反馈机制结合：若某部分空间上分布的信息素越多，那么在这个空间上走过的蚂蚁也就越多；走过的蚂蚁越多，在那个空间上留下的信息素也就越多，这就是存在的正反馈机制。但蚁群算法中解的构造是通过计算转移概率实现的，也就是说构造解的时候可以接受退化解，这限制了正反馈机制， java程序员必学的十种程序算法 算法1：快速排序算法 快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序 n 个项目要Ο(n log n)次比较。在最坏状况下则需要Ο(n2)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他Ο(n log n) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。 快速排序使用分治法（Divide and conquer）策略来把一个串行（list）分为两个子串行（sub-lists）。 算法步骤： 1 从数列中挑出一个元素，称为“基准”（pivot）， 2 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。 3 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。 递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会退出，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。 算法2：堆排序算法 堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。 堆排序的平均时间复杂度为Ο(nlogn) 。 算法步骤： 创建一个堆H[0..n-1] 把堆首（最大值）和堆尾互换 3. 把堆的尺寸缩小1，并调用shift_down(0),目的是把新的数组顶端数据调整到相应位置 4. 重复步骤2，直到堆的尺寸为1 算法3：归并排序 归并排序（Merge sort，台湾译作：合并排序）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。 算法步骤：数据结构与算法C语言版期末复习题
基于蚁群算法的MATLAB实现
算法程序
非常全的C语言常用算法
基于蚁群算法的路径规划
基本蚁群算法
C语言经典算法100例(1---30)
基于蚁群算法的机器人路径规划Ant Colony Algorithm
程序算法描述流程图.doc
蚁群算法matlab程序代码
C语言常用算法集合
十大编程算法助程序员走上高手之路
计算智能大作业--蚁群算法解决TSP问题
蚁群算法程序,在最短路中的应用,稍加扩展即可应用于机器人路径规划
最新C语言常用算法集合汇总
用蚁群算法解决TSP问题
(完整word版)基于蚁群算法的路径规划
java程序员必知的十种程序算法