蚁群算法简介

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

1. 蚁群算法简介
蚁群算法(Ant Clony Optimization,ACO)是一种群智能算法,它是由一群无智能或有轻微智能的个体(Agent)通过相互协作而表现出智能行为,从而为求解复杂问题提供了一个新的可能性。

蚁群算法最早是由意大利学者Colorni A., Dorigo M. 等于1991年提出。

经过20多年的发展,蚁群算法在理论以及应用研究上已经得到巨大的进步。

蚁群算法是一种仿生学算法,是由自然界中蚂蚁觅食的行为而启发的。

在自然界中,蚂蚁觅食过程中,蚁群总能够按照寻找到一条从蚁巢和食物源的最优路径。

图(1)显示了这样一个觅食的过程。

图(1)蚂蚁觅食
在图1(a)中,有一群蚂蚁,假如A是蚁巢,E是食物源(反之亦然)。

这群蚂蚁将沿着蚁巢和食物源之间的直线路径行驶。

假如在A和E之间突然出现了一个障碍物(图1(b)),那么,在B点(或D点)的蚂蚁将要做出决策,到底是向左行驶还是向右行驶?由于一开始路上没有前面蚂蚁留下的信息素(pheromone),蚂蚁朝着两个方向行进的概率是相等的。

但是当有蚂蚁走过时,它将会在它行进的路上释放出信息素,并且这种信息素会议一定的速率散发掉。

信息素是蚂蚁之间交流的工具之一。

它后面的蚂蚁通过路上信息素的浓度,做出决策,往左还是往右。

很明显,沿着短边的的路径上信息素将会越来越浓(图1(c)),从而吸引了越来越多的蚂蚁沿着这条路径行驶。

2. TSP问题描述
蚁群算法最早用来求解TSP问题,并且表现出了很大的优越性,因为它分布式特性,鲁棒性强并且容易与其它算法结合,但是同时也存在这收敛速度慢,容易陷入局部最优(local optimal)等缺点。

TSP问题(Travel Salesperson Problem,即旅行商问题或者称为中国邮递员问题),是一种,是一种NP-hard问题,此类问题用一般的算法是很大得到最优解的,所以一般需要借助一些启发式算法求解,例如遗传算法(GA),蚁群算法(ACO),微粒群算法(PSO)等等。

TSP问题可以分为两类,一类是对称TSP问题(Symmetric TSP),另一类是非对称问题(Asymmetric TSP)。

所有的TSP问题都可以用一个图(Graph)来描述:

V={c1, c2, …, c i, …, c n},i = 1,2, …, n,是所有城市的集合. c i表示第i个城市, n为城市的数目;
E={(r, s): r,s∈V}是所有城市之间连接的集合;
C = {c rs: r,s∈V}是所有城市之间连接的成本度量(一般为城市之间的距离);
如果c rs = c sr, 那么该TSP问题为对称的,否则为非对称的。

一个TSP问题可以表达为:
求解遍历图G = (V, E, C),所有的节点一次并且回到起始节点,使得连接这些节点的路径成
本最低。

3. 蚁群算法原理
假如蚁群中所有蚂蚁的数量为m,所有城市之间的信息素用矩阵pheromone表示,最短路径为bestLength,最佳路径为bestTour。

每只蚂蚁都有自己的内存,内存中用一个禁忌表(Tabu)来存储该蚂蚁已经访问过的城市,表示其在以后的搜索中将不能访问这些城市;还有用另外一个允许访问的城市表(Allowed)来存储它还可以访问的城市;另外还用一个矩阵(Delta)来存储它在一个循环(或者迭代)中给所经过的路径释放的信息素;还有另外一些数据,例如一些控制参数(,,,Q),该蚂蚁行走玩全程的总成本或距离(tourLength),等等。

假定算法总共运行MAX_GEN次,运行时间为t。

蚁群算法计算过程如下:
(1)初始化
设t=0,初始化bestLength为一个非常大的数(正无穷),bestTour为空。

初始化所有的蚂蚁的Delt矩阵所有元素初始化为0,Tabu表清空,Allowed表中加入所有的城市节点。

随机
选择它们的起始位置(也可以人工指定)。

在Tabu中加入起始节点,Allowed中去掉该起始
节点。

(2)为每只蚂蚁选择下一个节点。

为每只蚂蚁选择下一个节点,该节点只能从Allowed中以某种概率(公式1)搜索到,每搜到
一个,就将该节点加入到Tabu中,并且从Allowed中删除该节点。

该过程重复n-1次,直到所有的城市都遍历过一次。

遍历完所有节点后,将起始节点加入到Tabu中。

此时Tabu表元素数量为n+1(n为城市数量),Allowed元素数量为0。

接下来按照(公式2)计算每个蚂蚁
的Delta矩阵值。

最后计算最佳路径,比较每个蚂蚁的路径成本,然后和bestLength比较,
若它的路径成本比bestLength小,则将该值赋予bestLength,并且将其Tabu赋予BestTour。

(公式1)
(公式2)
其中表示选择城市j的概率,k表示第k个蚂蚁,表示城市i,j在第t时刻的信息素浓度,表示从城市i到城市j的可见度,
,表示城市i,j之间的成本(或距离)。

由此可见越小,越大,也就是从城市i到j的可见性就越大。

表示蚂蚁k在城市i与j之间留下的信息素。

表示蚂蚁k经过一个循环(或迭代)锁经过路径的总成本(或距离),即tourLength. ,,Q均为控制参数。

(3)更新信息素矩阵
令t = t + n,按照(公式3)更新信息素矩阵phermone。

(公式3)
为t+n时刻城市i与j之间的信息素浓度。

为控制参数,为城市i与j之间信息素经过一个迭代后的增量。

并且有
(公式4)
其中由公式计算得到。

(4)检查终止条件
如果达到最大代数MAX_GEN,算法终止,转到第(5)步;否则,重新初始化所有的蚂蚁的Delt矩阵所有元素初始化为0,Tabu表清空,Allowed表中加入所有的城市节点。

随机选择它们的起始位置(也可以人工指定)。

在Tabu中加入起始节点,Allowed中去掉该起始节点,重复执行(2),(3),(4)步。

(5)输出最优值
// AO.cpp : 定义控制台应用程序的入口点。

#pragma once
#include <iostream>
#include <math.h>
#include <time.h>
const double ALPHA=1.0; //启发因子,信息素的重要程度
const double BETA=2.0; //期望因子,城市间距离的重要程度
const double ROU=0.5; //信息素残留参数
const int N_ANT_COUNT=34; //蚂蚁数量
const int N_IT_COUNT=1000; //迭代次数
const int N_CITY_COUNT=51; //城市数量
const double DBQ=100.0; //总的信息素
const double DB_MAX=10e9; //一个标志数,10的9次方
double g_Trial[N_CITY_COUNT][N_CITY_COUNT]; //两两城市间信息素,就是环境信息素double g_Distance[N_CITY_COUNT][N_CITY_COUNT]; //两两城市间距离
//eil51.tsp城市坐标数据
double x_Ary[N_CITY_COUNT]=
{
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
};
double y_Ary[N_CITY_COUNT]=
{
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
};
//返回指定范围内的随机整数
int rnd(int nLow,int nUpper)
{
return nLow+(nUpper-nLow)*rand()/(RAND_MAX+1);
}
//返回指定范围内的随机浮点数
double rnd(double dbLow,double dbUpper)
{
double dbTemp=rand()/((double)RAND_MAX+1.0);
return dbLow+dbTemp*(dbUpper-dbLow);
}
//返回浮点数四舍五入取整后的浮点数
double ROUND(double dbA)
{
return (double)((int)(dbA+0.5));
}
//定义蚂蚁类
class CAnt
{
public:
CAnt(void);
~CAnt(void);
public:
int m_nPath[N_CITY_COUNT]; //蚂蚁走的路径
double m_dbPathLength; //蚂蚁走过的路径长度
int m_nAllowedCity[N_CITY_COUNT]; //没去过的城市 int m_nCurCityNo; //当前所在城市编号
int m_nMovedCityCount; //已经去过的城市数量public:
int ChooseNextCity(); //选择下一个城市
void Init(); //初始化
void Move(); //蚂蚁在城市间移动
void Search(); //搜索路径
void CalPathLength(); //计算蚂蚁走过的路径长度
};
//构造函数
CAnt::CAnt(void)
{
}
//析构函数
CAnt::~CAnt(void)
{
}
//初始化函数,蚂蚁搜索前调用
void CAnt::Init()
{
for (int i=0;i<N_CITY_COUNT;i++)
{
m_nAllowedCity[i]=1; //设置全部城市为没有去过
m_nPath[i]=0; //蚂蚁走的路径全部设置为0
}
//蚂蚁走过的路径长度设置为0
m_dbPathLength=0.0;
//随机选择一个出发城市
m_nCurCityNo=rnd(0,N_CITY_COUNT);
//把出发城市保存入路径数组中
m_nPath[0]=m_nCurCityNo;
//标识出发城市为已经去过了
m_nAllowedCity[m_nCurCityNo]=0;
//已经去过的城市数量设置为1
m_nMovedCityCount=1;
}
//选择下一个城市
//返回值为城市编号
int CAnt::ChooseNextCity()
{
int nSelectedCity=-1; //返回结果,先暂时把其设置为-1
//=================================================================== ===========
//计算当前城市和没去过的城市之间的信息素总和
double dbTotal=0.0;
double prob[N_CITY_COUNT]; //保存各个城市被选中的概率
for (int i=0;i<N_CITY_COUNT;i++)
{
if (m_nAllowedCity[i] == 1) //城市没去过
{
prob[i]=pow(g_Trial[m_nCurCityNo][i],ALPHA)*pow(1.0/g_Distance[m_nCurCityNo][i] ,BETA); //该城市和当前城市间的信息素
dbTotal=dbTotal+prob[i]; //累加信息素,得到总和
}
else //如果城市去过了,则其被选中的概率值为0
{
prob[i]=0.0;
}
}
//=================================================================== ===========
//进行轮盘选择
double dbTemp=0.0;
if (dbTotal > 0.0) //总的信息素值大于0
{
dbTemp=rnd(0.0,dbTotal); //取一个随机数
for (int i=0;i<N_CITY_COUNT;i++)
{
if (m_nAllowedCity[i] == 1) //城市没去过
{
dbTemp=dbTemp-prob[i]; //这个操作相当于转动轮盘,如果对轮盘选择不熟悉,仔细考虑一下
if (dbTemp < 0.0) //轮盘停止转动,记下城市编号,直接跳出循环
{
nSelectedCity=i;
break;
}
}
}
}
//=================================================================== ===========
//如果城市间的信息素非常小( 小到比double能够表示的最小的数字还要小)
//那么由于浮点运算的误差原因,上面计算的概率总和可能为0
//会出现经过上述操作,没有城市被选择出来
//出现这种情况,就把第一个没去过的城市作为返回结果
//题外话:刚开始看的时候,下面这段代码困惑了我很长时间,想不通为何要有这段代码,后来才搞清楚。

if (nSelectedCity == -1)
{
for (int i=0;i<N_CITY_COUNT;i++)
{
if (m_nAllowedCity[i] == 1) //城市没去过
{
nSelectedCity=i;
break;
}
}
}
//=================================================================== ===========
//返回结果,就是城市的编号
return nSelectedCity;
}
//蚂蚁在城市间移动
void CAnt::Move()
{
int nCityNo=ChooseNextCity(); //选择下一个城市
m_nPath[m_nMovedCityCount]=nCityNo; //保存蚂蚁走的路径 m_nAllowedCity[nCityNo]=0;//把这个城市设置成已经去过了 m_nCurCityNo=nCityNo; //改变当前所在城市为选择的城市 m_nMovedCityCount++; //已经去过的城市数量加1
}
//蚂蚁进行搜索一次
void CAnt::Search()
{
Init(); //蚂蚁搜索前,先初始化
//如果蚂蚁去过的城市数量小于城市数量,就继续移动
while (m_nMovedCityCount < N_CITY_COUNT)
{
Move();
}
//完成搜索后计算走过的路径长度
CalPathLength();
}
//计算蚂蚁走过的路径长度
void CAnt::CalPathLength()
{
m_dbPathLength=0.0; //先把路径长度置0
int m=0;
int n=0;
for (int i=1;i<N_CITY_COUNT;i++)
{
m=m_nPath[i];
n=m_nPath[i-1];
m_dbPathLength=m_dbPathLength+g_Distance[m][n];
}
//加上从最后城市返回出发城市的距离
n=m_nPath[0];
m_dbPathLength=m_dbPathLength+g_Distance[m][n];
}
//tsp类
class CTsp
{
public:
CTsp(void);
~CTsp(void);
public:
CAnt m_cAntAry[N_ANT_COUNT]; //蚂蚁数组
CAnt m_cBestAnt; //定义一个蚂蚁变量,用来保存搜索过程中的最优结果
//该蚂蚁不参与搜索,只是用来保存最优结果
public:
//初始化数据
void InitData();
//开始搜索
void Search();
//更新环境信息素
void UpdateTrial();
};
//构造函数
CTsp::CTsp(void)
{
}
CTsp::~CTsp(void)
{
}
//初始化数据
void CTsp::InitData()
{
//先把最优蚂蚁的路径长度设置成一个很大的值
m_cBestAnt.m_dbPathLength=DB_MAX;
//计算两两城市间距离
double dbTemp=0.0;
for (int i=0;i<N_CITY_COUNT;i++)
{
for (int j=0;j<N_CITY_COUNT;j++)
{
dbTemp=(x_Ary[i]-x_Ary[j])*(x_Ary[i]-x_Ary[j])+(y_Ary[i]-y_Ary[j])*(y_Ary[i]-y_Ary[ j]);
dbTemp=pow(dbTemp,0.5);
g_Distance[i][j]=ROUND(dbTemp);
}
}
//初始化环境信息素,先把城市间的信息素设置成一样
//这里设置成1.0,设置成多少对结果影响不是太大,对算法收敛速度有些影响
for (int i=0;i<N_CITY_COUNT;i++)
{
for (int j=0;j<N_CITY_COUNT;j++)
{
g_Trial[i][j]=1.0;
}
}
}
//更新环境信息素
void CTsp::UpdateTrial()
{
//临时数组,保存各只蚂蚁在两两城市间新留下的信息素
double dbTempAry[N_CITY_COUNT][N_CITY_COUNT];
memset(dbTempAry,0,sizeof(dbTempAry)); //先全部设置为0
//计算新增加的信息素,保存到临时数组里
int m=0;
int n=0;
for (int i=0;i<N_ANT_COUNT;i++) //计算每只蚂蚁留下的信息素
{
for (int j=1;j<N_CITY_COUNT;j++)
{
m=m_cAntAry[i].m_nPath[j];
n=m_cAntAry[i].m_nPath[j-1];
dbTempAry[n][m]=dbTempAry[n][m]+DBQ/m_cAntAry[i].m_dbPathLength;
dbTempAry[m][n]=dbTempAry[n][m];
}
//最后城市和开始城市之间的信息素
n=m_cAntAry[i].m_nPath[0];
dbTempAry[n][m]=dbTempAry[n][m]+DBQ/m_cAntAry[i].m_dbPathLength;
dbTempAry[m][n]=dbTempAry[n][m];
}
//================================================================== //更新环境信息素
for (int i=0;i<N_CITY_COUNT;i++)
{
for (int j=0;j<N_CITY_COUNT;j++)
{
g_Trial[i][j]=g_Trial[i][j]*ROU+dbTempAry[i][j]; //最新的环境信息素= 留存的信息素+ 新留下的信息素
}
}
}
void CTsp::Search()
{
char cBuf[256]; //打印信息用
//在迭代次数内进行循环
for (int i=0;i<N_IT_COUNT;i++)
{
//每只蚂蚁搜索一遍
for (int j=0;j<N_ANT_COUNT;j++)
{
m_cAntAry[j].Search();
}
//保存最佳结果
for (int j=0;j<N_ANT_COUNT;j++)
{
if (m_cAntAry[j].m_dbPathLength < m_cBestAnt.m_dbPathLength)
{
m_cBestAnt=m_cAntAry[j];
}
}
//更新环境信息素
UpdateTrial();
//输出目前为止找到的最优路径的长度
sprintf(cBuf,"\n[%d] %.0f",i+1,m_cBestAnt.m_dbPathLength);
printf(cBuf);
}
}
int main()
{
//用当前时间点初始化随机种子,防止每次运行的结果都相同
time_t tm;
time(&tm);
unsigned int nSeed=(unsigned int)tm;
srand(nSeed);
//开始搜索
CTsp tsp;
tsp.InitData(); //初始化
tsp.Search(); //开始搜索
//输出结果
printf("\nThe best tour is :\n");
char cBuf[128];
for (int i=0;i<N_CITY_COUNT;i++)
{
sprintf(cBuf,"d ",tsp.m_cBestAnt.m_nPath[i]+1); if (i % 20 == 0)
{
printf("\n");
}
printf(cBuf);
}
printf("\n\nPress any key to exit!");
getchar();
return 0;
}。

相关文档
最新文档