实现蚁群算法

⑴ 什么是蚁群算法，神经网络算法，遗传算法

蚁群算法又称蚂蚁算法，是一种用来在图中寻找优化路径的机率型算法。它由Marco Dorigo于1992年在他的博士论文中提出，其灵感来源于蚂蚁在寻找食物过程中发现路径的行为。蚁群算法是一种模拟进化算法,初步的研究表明该算法具有许多优良的性质.针对PID控制器参数优化设计问题,将蚁群算法设计的结果与遗传算法设计的结果进行了比较,数值仿真结果表明,蚁群算法具有一种新的模拟进化优化方法的有效性和应用价值。

神经网络
思维学普遍认为，人类大脑的思维分为抽象（逻辑）思维、形象（直观）思维和灵感（顿悟）思维三种基本方式。
逻辑性的思维是指根据逻辑规则进行推理的过程；它先将信息化成概念，并用符号表示，然后，根据符号运算按串行模式进行逻辑推理；这一过程可以写成串行的指令，让计算机执行。然而，直观性的思维是将分布式存储的信息综合起来，结果是忽然间产生想法或解决问题的办法。这种思维方式的根本之点在于以下两点:1.信息是通过神经元上的兴奋模式分布储在网络上;2.信息处理是通过神经元之间同时相互作用的动态过程来完成的。
人工神经网络就是模拟人思维的第二种方式。这是一个非线性动力学系统，其特色在于信息的分布式存储和并行协同处理。虽然单个神经元的结构极其简单，功能有限，但大量神经元构成的网络系统所能实现的行为却是极其丰富多彩的。
神经网络的研究内容相当广泛，反映了多学科交叉技术领域的特点。目前，主要的研究工作集中在以下几个方面：
（1）生物原型研究。从生理学、心理学、解剖学、脑科学、病理学等生物科学方面研究神经细胞、神经网络、神经系统的生物原型结构及其功能机理。
（2）建立理论模型。根据生物原型的研究，建立神经元、神经网络的理论模型。其中包括概念模型、知识模型、物理化学模型、数学模型等。
（3）网络模型与算法研究。在理论模型研究的基础上构作具体的神经网络模型，以实现计算机馍拟或准备制作硬件，包括网络学习算法的研究。这方面的工作也称为技术模型研究。
（4）人工神经网络应用系统。在网络模型与算法研究的基础上，利用人工神经网络组成实际的应用系统，例如，完成某种信号处理或模式识别的功能、构作专家系统、制成机器人等等。
纵观当代新兴科学技术的发展历史，人类在征服宇宙空间、基本粒子，生命起源等科学技术领域的进程中历经了崎岖不平的道路。我们也会看到，探索人脑功能和神经网络的研究将伴随着重重困难的克服而日新月异。
遗传算法，是模拟达尔文生物进化论的自然选择和遗传学机理的生物进化过程的计算模型，是一种通过模拟自然进化过程搜索最优解的方法，它最初由美国Michigan大学J.Holland教授于1975年首先提出来的，并出版了颇有影响的专着《Adaptation in Natural and Artificial Systems》，GA这个名称才逐渐为人所知，J.Holland教授所提出的GA通常为简单遗传算法（SGA）。

⑵ 蚁群算法难学吗

难学。
一些超级难的算法有遗传算法，蚁群算法。蚁群算法基本原理：在自然界中，生物群体所表现出的智能得到越来越多的关注，许多的群智能优化算法都是通过对群体智能的模拟而实现的。其中模拟蚂蚁群体觅食的蚁群算法成为一种主要的群智能算法。算法原理：在自然界中，对于觅食的蚂蚁群体，其可以在任何和没有提示的情况下找到食物和巢穴之间的最短路径。并且能够根据和环境的变迁，自适应地找到新的最优路径。根据生物学家研究，蚂蚁群体这一行为的根本原因是：蚂蚁在寻找食物的过程中，能在其走过的路径上释放一种特殊的物质信息素，随着时间的推移，这种信息素会逐渐地挥发，而对于后来的蚂蚁，选择某条路径的概率与该路径上信息素的浓度成正比。当某一条路径上通过的蚂蚁越多的时候，这条路径上的信息素的浓度就会累积越大，后来的蚂蚁选择此路径的概率也就越大。路径上蚂蚁越多，导致信息素浓度越高，从而会吸引更多的蚂蚁，从而形成一种正反馈机制，通过这种机制，最终蚁群可以发现最短路径。

⑶ 蚁群算法中转移概率是怎么用的.不同的蚂蚁为什么会选择不同的路径

因为不同路径的信息素和启发信息不同，所以向每条路径转移的概率也不同；
具体实现可以运用轮盘赌选择，转移概率越大的路径就会有更多的蚂蚁选择.。
Prime 算法和 Kruskal 算法都是用来求加权连通简单图中权和最小的支撑树（即最小树）的，Prime算法的时间复杂度为O(n^2) （n 为顶点数），Kruskal 算法的时间复杂度为 O(eln(e)) （e为边数），这两种算法都是多项式时间算法，也就是说，最小树问题已经有了有效算法去求解，属于P问题。
Dijkstra 算法求解的是加权连通简单图中一个顶点到其它每个顶点的具有最小权和的有向路，最简单版本的时间复杂度是O(n^2)，也是多项式时间算法。
而蚁群算法是一种近似算法，它不是用来解决已存在精确有效算法的问题的，而是用来解决至今没有找到精确的有效算法的问题的，比如旅行商问题（TSP）。
旅行商问题也可以说是求“最短路径”，但它是求一个完全图的最小哈密顿圈，这个问题至今未找到多项式时间算法，属于NPC问题，也就是说，当问题规模稍大一点，现有的精确算法的运算量就会急剧增加。
文中的某些观点引自知乎大神余幸恩，感谢帮忙！~

⑷ 蚁群算法java版

说明：信息素权重，路径权重和信息素蒸发率对最后的结果影响很大，需要微调。
目前发现2 / 5 / 0.5 能达到稍微让人满意的效果。本程序离完美的ACO还差很远，仅供参考。
本蚁群算法为AS算法。

用法：

1.new一个对象
ACOforTSP tsp = new ACPforTSP(tsp数据文件名,迭代次数，蚂蚁数量，信息素权重，路径权重，信息素蒸发率）;
2.用go()方法运行
tsp.go();

ACOforTSP.java
___________________________________________________________________
import java.io.File;
import static java.lang.Math.pow;
import static java.lang.Math.sqrt;
import static java.lang.Math.random;
import java.util.HashMap;
import java.io.FileReader;
import java.io.BufferedReader;
/**
*
* @author dvdface
*/

public class ACOforTSP {

//城市的距离表
private double[][] distance;
//距离的倒数表
private double[][] heuristic;
//启发信息表
private double[][] pheromone;
//权重
private int alpha, beta;
//迭代的次数
private int iterationTimes;
//蚂蚁的数量
private int numbersOfAnt;
//蒸发率
private double rate;

ACOforTSP (String file, int iterationTimes, int numbersOfAnt, int alpha, int beta, double rate) {

//加载文件
this.initializeData(file);
//初始化参数
this.iterationTimes = iterationTimes;
//设置蚂蚁数量
this.numbersOfAnt = numbersOfAnt;
//设置权重
this.alpha = alpha;
this.beta = beta;
//设置蒸发率
this.rate = rate;
}

private void initializeData(String filename) {

//定义内部类
class City {

int no;
double x;
double y;

City(int no, double x, double y) {

this.no = no;
this.x = x;
this.y = y;
}

private double getDistance(City city) {

return sqrt(pow((x - city.x), 2) + pow((y - city.y), 2));
}
}

try {
//定义HashMap保存读取的坐标信息
HashMap<Integer, City> map = new HashMap<Integer, City>();
//读取文件
BufferedReader reader = new BufferedReader(new FileReader(new File(filename)));
for (String str = reader.readLine(); str != null; str = reader.readLine()) {
//将读到的信息保存入HashMap
if (str.matches("([0-9]+)(\\s*)([0-9]+)(.?)([0-9]*)(\\s*)([0-9]+)(.?)([0-9]*)")) {

String[] data = str.split("(\\s+)");
City city = new City(Integer.parseInt(data[0]),
Double.parseDouble(data[1]),
Double.parseDouble(data[2]));

map.put(city.no, city);
}
}
//分配距离矩阵存储空间
distance = new double[map.size() + 1][map.size() + 1];
//分配距离倒数矩阵存储空间
heuristic = new double[map.size() + 1][map.size() + 1];
//分配信息素矩阵存储空间
pheromone = new double[map.size() + 1][map.size() + 1];
for (int i = 1; i < map.size() + 1; i++) {
for (int j = 1; j < map.size() + 1; j++) {
//计算城市间的距离，并存入距离矩阵
distance[i][j] = map.get(i).getDistance(map.get(j));
//计算距离倒数，并存入距离倒数矩阵
heuristic[i][j] = 1 / distance[i][j];
//初始化信息素矩阵
pheromone[i][j] = 1;
}
}

} catch (Exception exception) {

System.out.println("初始化数据失败！");
}
}

class Ant {

//已访问城市列表
private boolean[] visited;
//访问顺序表
private int[] tour;
//已访问城市的个数
private int n;
//总的距离
private double total;

Ant() {
//给访问顺序表分配空间
tour = new int[distance.length+1];
//已存入城市数量为n，刚开始为0
n = 0;
//将起始城市1,放入访问结点顺序表第一项
tour[++n] = 1;
//给已访问城市结点分配空间
visited = new boolean[distance.length];
//第一个城市为出发城市，设置为已访问
visited[tour[n]] = true;
}

private int chooseCity() {

//用来random的随机数
double m = 0;
//获得当前所在的城市号放入j,如果和j相邻的城市没有被访问，那么加入m
for (int i = 1, j = tour[n]; i < pheromone.length; i++) {

if (!visited[i]) {
m += pow(pheromone[j][i], alpha) * pow(heuristic[j][i], beta);
}
}

//保存随机到的数
double p = m * random();
//寻找被随机到的城市
double k = 0;
//保存找到的城市
int q = 0;
for (int i = 1, j = tour[n]; k < p; i++) {

if (!visited[i]) {

k += pow(pheromone[j][i], alpha) * pow(heuristic[j][i], beta);
q = i;
}
}

return q;
}

private void constructSolution () {

while (n != (distance.length-1) ) {

//选取下一个城市
int p = chooseCity();
//计算总的距离
total += distance[tour[n]][p];
//将选取到的城市放入已访问列表
tour[++n] = p;
//将选取到的城市标记为已访问
visited[p] = true;
}

//回到起点
total += distance[tour[1]][tour[n]];
//将起点加入访问顺序表的最后
tour[++n] = tour[1];
}

private void releasePheromone() {

//释放信息素的大小
double t = 1/total;
//释放信息素
for (int i=1;i<tour.length-1;i++) {

pheromone[tour[i]][tour[i+1]] += t;
pheromone[tour[i+1]][tour[i]] += t;
}
}

}

public void go() {

//保存最好的路径和路径长度
double bestTotal = Double.MAX_VALUE;
int[] bestTour = new int[distance.length+1];

//新建蚂蚁数组，用来引用所创建的蚂蚁
Ant[] ant = new Ant[numbersOfAnt];

//进行iterationTimes次迭代
while (iterationTimes != 0) {
//初始化新的一批蚂蚁（这里用构造新的蚂蚁代替重置蚂蚁状态）
for (int i=0; i<numbersOfAnt; i++) {
ant[i] = new Ant();
}

//进行一次迭代（即让所有的蚂蚁构建一条路径）
for (int i=0; i<numbersOfAnt; i++) {

ant[i].constructSolution();
//如果蚂蚁构建的路径长度比上次最好的还好，那么保存这个长度和它所走的路径
if (ant[i].total<bestTotal) {

bestTotal = ant[i].total;
System.array(ant[i].tour, 1, bestTour, 1, bestTour.length-1);
}
}

//蒸发信息素
evaporatePheromone();

//释放信息素
for (int i=0; i<numbersOfAnt; i++) {

ant[i].releasePheromone();
}

//报告本次迭代的信息
System.out.format("本次为倒数第%d次迭代,当前最优路径长度为%10.2f\n",iterationTimes,bestTotal);

//迭代总数减去1，进行下次迭代
iterationTimes--;
}

//输出最好的路径长度
System.out.format("得到的最优的路径长度为:%10.2f\n",bestTotal);
//输出最好的路径
System.out.println("最优路径如下：");
for (int i=1; i<bestTour.length; i++) {

System.out.print("→"+bestTour[i]);
}
}

private void evaporatePheromone() {

for (int i = 1; i < pheromone.length; i++)
for (int j = 1; j < pheromone.length; j++) {

pheromone[i][j] *= 1-rate;
}

}
}

⑸ 求带注释的蚁群算法

Sorry，没有注释！
放不下，网站上有！

下面就是实现如此复杂性的七条简单规则：
1、范围：
蚂蚁观察到的范围是一个方格世界，蚂蚁有一个参数为速度半径（一般是3），那么它能观察到的范围就是33个方格世界，并且能移动的距离也在这个范围之内。
2、环境：
蚂蚁所在的环境是一个虚拟的世界，其中有障碍物，有别的蚂蚁，还有信息素，信息素有两种，一种是找到食物的蚂蚁洒下的食物信息素，一种是找到窝的蚂蚁洒下的窝的信息素。每个蚂蚁都仅仅能感知它范围内的环境信息。环境以一定的速率让信息素消失。
3、觅食规则：
在每只蚂蚁能感知的范围内寻找是否有食物，如果有就直接过去。否则看是否有信息素，并且比较在能感知的范围内哪一点的信息素最多，这样，它就朝信息素多的地方走，并且每只蚂蚁多会以小概率犯错误，从而并不是往信息素最多的点移动。蚂蚁找窝的规则和上面一样，只不过它对窝的信息素做出反应，而对食物信息素没反应。
4、移动规则：
每只蚂蚁都朝向信息素最多的方向移，并且，当周围没有信息素指引的时候，蚂蚁会按照自己原来运动的方向惯性的运动下去，并且，在运动的方向有一个随机的小的扰动。为了防止蚂蚁原地转圈，它会记住最近刚走过了哪些点，如果发现要走的下一点已经在最近走过了，它就会尽量避开。
5、避障规则：
如果蚂蚁要移动的方向有障碍物挡住，它会随机的选择另一个方向，并且有信息素指引的话，它会按照觅食的规则行为。
7、播撒信息素规则：
每只蚂蚁在刚找到食物或者窝的时候撒发的信息素最多，并随着它走远的距离，播撒的信息素越来越少。

下面的程序开始运行之后，蚂蚁们开始从窝里出动了，寻找食物；他们会顺着屏幕爬满整个画面，直到找到食物再返回窝。

其中，‘F’点表示食物，‘H’表示窝，白色块表示障碍物，‘+’就是蚂蚁了。

参数说明：
最大信息素：蚂蚁在一开始拥有的信息素总量，越大表示程序在较长一段时间能够存在信息素。信息素消减的速度：随着时间的流逝，已经存在于世界上的信息素会消减，这个数值越大，那么消减的越快。
错误概率表示这个蚂蚁不往信息素最大的区域走的概率，越大则表示这个蚂蚁越有创新性。
速度半径表示蚂蚁一次能走的最大长度，也表示这个蚂蚁的感知范围。
记忆能力表示蚂蚁能记住多少个刚刚走过点的坐标，这个值避免了蚂蚁在本地打转，停滞不前。而这个值越大那么整个系统运行速度就慢，越小则蚂蚁越容易原地转圈。

源代码如下：

ant.c

#define SPACE 0×20
#define ESC 0×1b
#define ANT_CHAR_EMPTY ‘+’
#define ANT_CHAR_FOOD 153
#define HOME_CHAR ‘H’
#define FOOD_CHAR ‘F’
#define FOOD_CHAR2 ‘f’
#define FOOD_HOME_COLOR 12
#define BLOCK_CHAR 177

#define MAX_ANT 50
#define INI_SPEED 3
#define MAXX 80
#define MAXY 23
#define MAX_FOOD 10000
#define TARGET_FOOD 200
#define MAX_SMELL 5000
#define SMELL_DROP_RATE 0.05
#define ANT_ERROR_RATE 0.02
#define ANT_EYESHOT 3
#define SMELL_GONE_SPEED 50
#define SMELL_GONE_RATE 0.05
#define TRACE_REMEMBER 50
#define MAX_BLOCK 100

#define NULL 0
#define UP 1
#define DOWN 2
#define LEFT 3
#define RIGHT 4
#define SMELL_TYPE_FOOD 0
#define SMELL_TYPE_HOME 1

#include “stdio.h”
#include “conio.h”
#include “dos.h”
#include “stdlib.h”
#include “dos.h”
#include “process.h”
#include “ctype.h”
#include “math.h”

void WorldInitial(void);
void BlockInitial(void);
void CreatBlock(void);
void SaveBlock(void);
void LoadBlock(void);
void HomeFoodInitial(void);
void AntInitial(void);
void WorldChange(void);
void AntMove(void);
void AntOneStep(void);
void DealKey(char key);
void ClearSmellDisp(void);
void DispSmell(int type);
int AntNextDir(int xxx,int yyy,int ddir);
int GetMaxSmell(int type,int xxx,int yyy,int ddir);
int IsTrace(int xxx,int yyy);
int MaxLocation(int num1,int num2,int num3);
int CanGo(int xxx,int yyy,int ddir);
int JudgeCanGo(int xxx,int yyy);
int TurnLeft(int ddir);
int TurnRight(int ddir);
int TurnBack(int ddir);

int MainTimer(void);
char WaitForKey(int secnum);
void DispPlayTime(void);
int TimeUse(void);
void HideCur(void);
void ResetCur(void);

—————
struct HomeStruct
{
int xxx,yyy;
int amount;
int TargetFood;
}home;

struct FoodStruct
{
int xxx,yyy;
int amount;
}food;

struct AntStruct
{
int xxx,yyy;
int dir;
int speed;
int SpeedTimer;
int food;
int SmellAmount[2];
int tracex[TRACE_REMEMBER];
int tracey[TRACE_REMEMBER];
int TracePtr;
int IQ;
}ant[MAX_ANT];
int AntNow;
int timer10ms;
struct time starttime,endtime;
int Smell[2][MAXX+1][MAXY+1];
int block[MAXX+1][MAXY+1];
int SmellGoneTimer;
int SmellDispFlag;
int CanFindFood;
int HardtoFindPath;

—– Main ——–
void main(void)
{
char KeyPress;
int tu;

clrscr();
HideCur();
WorldInitial();
do
{
timer10ms = MainTimer();
if(timer10ms) AntMove();
if(timer10ms) WorldChange();
tu = TimeUse();
if(tu=60&&!CanFindFood)
{
gotoxy(1,MAXY+1);
printf(“Can not find food, maybe a block world.”);
WaitForKey(10);
WorldInitial();
}
if(tu=180&&home.amount100&&!HardtoFindPath)
{
gotoxy(1,MAXY+1);
printf(“God! it is so difficult to find a path.”);
if(WaitForKey(10)==0×0d) WorldInitial();
else
{
HardtoFindPath = 1;
gotoxy(1,MAXY+1);
printf(” “);
}
}
if(home.amount=home.TargetFood)
{
gettime(&endtime);
KeyPress = WaitForKey(60);
DispPlayTime();
WaitForKey(10);
WorldInitial();
}
else if(kbhit())
{
KeyPress = getch();
DealKey(KeyPress);
}
else KeyPress = NULL;
}
while(KeyPress!=ESC);
gettime(&endtime);
DispPlayTime();
WaitForKey(10);
clrscr();
ResetCur();
}

⑹ 蚁群算法的定义

各个蚂蚁在没有事先告诉他们食物在什么地方的前提下开始寻找食物。当一只找到食物以后，它会向环境释放一种挥发性分泌物pheromone (称为信息素,该物质随着时间的推移会逐渐挥发消失，信息素浓度的大小表征路径的远近)来实现的，吸引其他的蚂蚁过来，这样越来越多的蚂蚁会找到食物。有些蚂蚁并没有像其它蚂蚁一样总重复同样的路，他们会另辟蹊径，如果另开辟的道路比原来的其他道路更短，那么，渐渐地，更多的蚂蚁被吸引到这条较短的路上来。最后，经过一段时间运行，可能会出现一条最短的路径被大多数蚂蚁重复着。

⑺ 如何用蚁群算法来计算固定时间内走更多的城市且路程最短

概念：蚁群算法(ant colony optimization,ACO),又称蚂蚁算法,是一种用来在图中寻找优化路径的机率型算法.它由Marco Dorigo于1992年在他的博士论文中提出,其灵感来源于蚂蚁在寻找食物过程中发现路径的行为.蚁群算法是一种模拟进化算法,初步的研究表明该算法具有许多优良的性质.针对PID控制器参数优化设计问题,将蚁群算法设计的结果与遗传算法设计的结果进行了比较,数值仿真结果表明,蚁群算法具有一种新的模拟进化优化方法的有效性和应用价值
其原理：为什么小小的蚂蚁能够找到食物?他们具有智能么?设想,如果我们要为蚂蚁设计一个人工智能的程序,那么这个程序要多么复杂呢?首先,你要让蚂蚁能够避开障碍物,就必须根据适当的地形给它编进指令让他们能够巧妙的避开障碍物,其次,要让蚂蚁找到食物,就需要让他们遍历空间上的所有点；再次,如果要让蚂蚁找到最短的路径,那么需要计算所有可能的路径并且比较它们的大小,而且更重要的是,你要小心翼翼的编程,因为程序的错误也许会让你前功尽弃.这是多么不可思议的程序!太复杂了,恐怕没人能够完成这样繁琐冗余的程序
应用范围：蚂蚁观察到的范围是一个方格世界,蚂蚁有一个参数为速度半径（一般是3）,那么它能观察到的范围就是3*3个方格世界,并且能移动的距离也在这个范围之内
引申：跟着蚂蚁的踪迹,你找到了什么?通过上面的原理叙述和实际操作,我们不难发现蚂蚁之所以具有智能行为,完全归功于它的简单行为规则,而这些规则综合起来具有下面两个方面的特点：1、多样性 2、正反馈 多样性保证了蚂蚁在觅食的时候不置走进死胡同而无限循环,正反馈机制则保证了相对优良的信息能够被保存下来.我们可以把多样性看成是一种创造能力,而正反馈是一种学习强化能力.正反馈的力量也可以比喻成权威的意见,而多样性是打破权威体现的创造性,正是这两点小心翼翼的巧妙结合才使得智能行为涌现出来了.引申来讲,大自然的进化,社会的进步、人类的创新实际上都离不开这两样东西,多样性保证了系统的创新能力,正反馈保证了优良特性能够得到强化,两者要恰到好处的结合.如果多样性过剩,也就是系统过于活跃,这相当于蚂蚁会过多的随机运动,它就会陷入混沌状态；而相反,多样性不够,正反馈机制过强,那么系统就好比一潭死水.这在蚁群中来讲就表现为,蚂蚁的行为过于僵硬,当环境变化了,蚂蚁群仍然不能适当的调整.既然复杂性、智能行为是根据底层规则涌现的,既然底层规则具有多样性和正反馈特点,那么也许你会问这些规则是哪里来的?多样性和正反馈又是哪里来的?我本人的意见：规则来源于大自然的进化.而大自然的进化根据刚才讲的也体现为多样性和正反馈的巧妙结合.而这样的巧妙结合又是为什么呢?为什么在你眼前呈现的世界是如此栩栩如生呢?答案在于环境造就了这一切,之所以你看到栩栩如生的世界,是因为那些不能够适应环境的多样性与正反馈的结合都已经死掉了,被环境淘汰了!蚁群算法的实现 下面的程序开始运行之后,蚂蚁们开始从窝里出动了,寻找食物；他们会顺着屏幕爬满整个画面,直到找到食物再返回窝.其中,‘F’点表示食物,‘H’表示窝,白色块表示障碍物,‘+’就是蚂蚁了.

⑻ 蚁群算法信息素在路由协议中的实现

述了。
目前蚁群算法主要用在组合优化方面，基本蚁群算法的思路是这样的：
1.
在初始状态下，一群蚂蚁外出，此时没有信息素，那么各自会随机的选择一条路径。
2.
在下一个状态，每只蚂蚁到达了不同的点，从初始点到这些点之间留下了信息素，蚂蚁继续走，已经到达目标的蚂蚁开始返回，与此同时，下一批蚂蚁出动，它们都会按照各条路径上信息素的多少选择路线(selection)，更倾向于选择信息素多的路径走（当然也有随机性）。
3.
又到了再下一个状态，刚刚没有蚂蚁经过的路线上的信息素不同程度的挥发掉了(evaporation)，而刚刚经过了蚂蚁的路线信息素增强(reinforcement)。然后又出动一批蚂蚁，重复第2个步骤。
每个状态到下一个状态的变化称为一次迭代，在迭代多次过后，就会有某一条路径上的信息素明显多于其它路径，这通常就是一条最优路径。
关键的部分在于步骤2和3：
步骤2中，每只蚂蚁都要作出选择，怎样选择呢？
selection过程用一个简单的函数实现：
蚂蚁选择某条路线的概率＝该路线上的信息素÷所有可选择路线的信息素之和
假设蚂蚁在i点，p(i,j)表示下一次到达j点的概率，而τ(i,j)表示ij两点间的信息素，则：
p(i,j)＝τ(i,j)/∑τ(i)
（如果所有可选路线的信息素之和∑τ(i)＝0，即前面还没有蚂蚁来过，概率就是一个[0,1]上的随机值，即随机选择一条路线）
步骤3中，挥发和增强是算法的关键所在（也就是如何数学定义信息素的）
evaporation过程和reinforcement过程定义了一个挥发因子，是迭代次数k的一个函数
ρ(k)＝1－lnk/ln(k+1)
最初设定每条路径的信息素τ(i,j,0)为相同的值
然后，第k+1次迭代时，信息素的多少
对于没有蚂蚁经过的路线：τ(i,j,k+1)＝(1－ρ(k))τ(i,j,k)，显然信息素减少了
有蚂蚁经过的路线：τ(i,j,k+1)＝(1－ρ(k))τ(i,j,k)＋ρ(k)/|W|，W为所有点的集合
为什么各个函数要如此定义，这个问题很难解释清楚，这也是算法的精妙所在。如此定义信息素的挥发和增强，以及路径选择，根据马尔可夫过程（随机过程之一）能够推导出，在迭代了足够多次以后，算法能够收敛到最佳路径。
组合优化很有意思的，像禁忌搜索、模拟退火、蚁群算法、遗传算法、神经网络这些算法能够解决很多生活中的实际问题，楼主有空可以招本书看看。

⑼ 蚁群算法怎样用MATLAB仿真

蚁群算法采用matlab开发的仿真平台：算法实现，路径显示，人机交互控制等
希望对你有帮助！
是可以运行的
% the procere of ant colony algorithm for VRP
%
% % % % % % % % % % %

%initialize the parameters of ant colony algorithms
load data.txt;
d=data(:,2:3);
g=data(:,4);
m=31; % 蚂蚁数
alpha=1;
belta=4;% 决定tao和miu重要性的参数
lmda=0;
rou=0.9;%衰减系数
q0=0.95;
% 概率
tao0=1/(31*841.04);%初始信息素
Q=1;%蚂蚁循环一周所释放的信息素
defined_phrm=15.0; % initial pheromone level value
QV=100; % 车辆容量
vehicle_best=round(sum(g)/QV)+1;%所完成任务所需的最少车数
V=40;
% 计算两点的距离
for i=1:32;
for j=1:32;
dist(i,j)=sqrt((d(i,1)-d(j,1))^2+(d(i,2)-d(j,2))^2);
end;
end;
%给tao miu赋初值
for i=1:32;
for j=1:32;
if i~=j;
%s(i,j)=dist(i,1)+dist(1,j)-dist(i,j);
tao(i,j)=defined_phrm;
miu(i,j)=1/dist(i,j);
end;
end;
end;

for k=1:32;
for k=1:32;
deltao(i,j)=0;
end;
end;
best_cost=10000;
for n_gen=1:50;
print_head(n_gen);
for i=1:m;
%best_solution=[];
print_head2(i);
sumload=0;
cur_pos(i)=1;
rn=randperm(32);
n=1;
nn=1;
part_sol(nn)=1;
%cost(n_gen,i)=0.0;
n_sol=0; % 由蚂蚁产生的路径数量
M_vehicle=500;
t=0; %最佳路径数组的元素数为0

while sumload<=QV;

for k=1:length(rn);
if sumload+g(rn(k))<=QV;
gama(cur_pos(i),rn(k))=(sumload+g(rn(k)))/QV;
A(n)=rn(k);
n=n+1;
end;
end;
fid=fopen('out_customer.txt','a+');
fprintf(fid,'%s %i\t','the current position is:',cur_pos(i));
fprintf(fid,'\n%s','the possible customer set is:')
fprintf(fid,'\t%i\n',A);
fprintf(fid,'------------------------------\n');
fclose(fid);

p=compute_prob(A,cur_pos(i),tao,miu,alpha,belta,gama,lmda,i);
maxp=1e-8;
na=length(A);
for j=1:na;
if p(j)>maxp
maxp=p(j);
index_max=j;
end;
end;

old_pos=cur_pos(i);
if rand(1)<q0
cur_pos(i)=A(index_max);
else
krnd=randperm(na);
cur_pos(i)=A(krnd(1));
bbb=[old_pos cur_pos(i)];
ccc=[1 1];
if bbb==ccc;
cur_pos(i)=A(krnd(2));
end;
end;

tao(old_pos,cur_pos(i))=taolocalupdate(tao(old_pos,cur_pos(i)),rou,tao0);%对所经弧进行局部更新

sumload=sumload+g(cur_pos(i));

nn=nn+1;
part_sol(nn)=cur_pos(i);
temp_load=sumload;

if cur_pos(i)~=1;
rn=setdiff(rn,cur_pos(i));
n=1;
A=[];
end;

if cur_pos(i)==1; % 如果当前点为车场,将当前路径中的已访问用户去掉后,开始产生新路径
if setdiff(part_sol,1)~=[];
n_sol=n_sol+1; % 表示产生的路径数,n_sol=1,2,3,..5,6...,超过5条对其费用加上车辆的派遣费用
fid=fopen('out_solution.txt','a+');
fprintf(fid,'%s%i%s','NO.',n_sol,'条路径是:');
fprintf(fid,'%i ',part_sol);
fprintf(fid,'\n');
fprintf(fid,'%s','当前的用户需求量是:');
fprintf(fid,'%i\n',temp_load);
fprintf(fid,'------------------------------\n');
fclose(fid);

% 对所得路径进行路径内3-opt优化
final_sol=exchange(part_sol);

for nt=1:length(final_sol); % 将所有产生的路径传给一个数组
temp(t+nt)=final_sol(nt);
end;
t=t+length(final_sol)-1;

sumload=0;
final_sol=setdiff(final_sol,1);
rn=setdiff(rn,final_sol);
part_sol=[];
final_sol=[];
nn=1;
part_sol(nn)=cur_pos(i);
A=[];
n=1;

end;
end;

if setdiff(rn,1)==[];% 产生最后一条终点不为1的路径
n_sol=n_sol+1;
nl=length(part_sol);
part_sol(nl+1)=1;%将路径的最后1位补1

% 对所得路径进行路径内3-opt优化
final_sol=exchange(part_sol);

for nt=1:length(final_sol); % 将所有产生的路径传给一个数组
temp(t+nt)=final_sol(nt);
end;

cost(n_gen,i)=cost_sol(temp,dist)+M_vehicle*(n_sol-vehicle_best); %计算由蚂蚁i产生的路径总长度

for ki=1:length(temp)-1;
deltao(temp(ki),temp(ki+1))=deltao(temp(ki),temp(ki+1))+Q/cost(n_gen,i);
end;

if cost(n_gen,i)<best_cost;
best_cost=cost(n_gen,i);
old_cost=best_cost;
best_gen=n_gen; % 产生最小费用的代数
best_ant=i; %产生最小费用的蚂蚁
best_solution=temp;
end;

if i==m;%如果所有蚂蚁均完成一次循环，，则用最佳费用所对应的路径对弧进行整体更新
for ii=1:32;
for jj=1:32;
tao(ii,jj)=(1-rou)*tao(ii,jj);
end;
end;

for kk=1:length(best_solution)-1;

tao(best_solution(kk),best_solution(kk+1))=tao(best_solution(kk),best_solution(kk+1))+deltao(best_solution(kk),best_solution(kk+1));
end;
end;

fid=fopen('out_solution.txt','a+');
fprintf(fid,'%s%i%s','NO.',n_sol,'路径是:');
fprintf(fid,'%i ',part_sol);
fprintf(fid,'\n');
fprintf(fid,'%s %i\n','当前的用户需求量是:',temp_load);
fprintf(fid,'%s %f\n','总费用是:',cost(n_gen,i));
fprintf(fid,'------------------------------\n');
fprintf(fid,'%s\n','最终路径是:');
fprintf(fid,'%i-',temp);
fprintf(fid,'\n');
fclose(fid);
temp=[];
break;
end;
end;

end;
end;

⑽ 你知道怎么用matlab实现蚁群算法么

PSO算法吗？网上很多源代码，自己写的话也很快。核心就是那几个迭代公式