蚁群算法
蚁群算法(ant colony optimization, ACO)，又称蚂蚁算法，是一种用来在图中寻找优化路径的机率型算法。它由Marco Dorigo于1992年在他的博士论文中提出，其灵感来源于蚂蚁在寻找食物过程中发现路径的行为。蚁群算法是一种模拟进化算法，初步的研究表明该算法具有许多优良的性质。针对PID控制器参数优化设计问题，将蚁群算法设计的结果与遗传算法设计的结果进行了比较，数值仿真结果表明，蚁群算法具有一种新的模拟进化优化方法的有效性和应用价值。
如果我们要为蚂蚁设计一个人工智能的程序，那么这个程序要多么复杂呢？首先，你要让蚂蚁能够避开障碍物，就必须根据适当的地形给它编进指令让他们能够巧妙的避开障碍物，其次，要让蚂蚁找到食物，就需要让他们遍历空间上的所有点；再次，如果要让蚂蚁找到最短的路径，那么需要计算所有可能的路径并且比较它们的大小，而且更重要的是，你要小心翼翼地编程，因为程序的错误也许会让你前功尽弃。这是多么不可思议的程序！太复杂了，恐怕没人能够完成这样繁琐冗余的程序。
然而，事实并没有你想得那么复杂，上面这个程序每个蚂蚁的核心程序编码不过100多行！为什么这么简单的程序会让蚂蚁干这样复杂的事情？答案是：简单规则的涌现。事实上，每只蚂蚁并不是像我们想象的需要知道整个世界的信息，他们其实只关心很小范围内的眼前信息，而且根据这些局部信息利用几条简单的规则进行决策，这样，在蚁群这个集体里，复杂性的行为就会凸现出来。这就是人工生命、复杂性科学解释的规律！那么，这些简单规则是什么呢？
1、范围
蚂蚁观察到的范围是一个方格世界，蚂蚁有一个参数为速度半径（一般是3），那么它能观察到的范围就是3*3个方格世界，并且能移动的距离也在这个范围之内。
2、环境
蚂蚁所在的环境是一个虚拟的世界，其中有障碍物，有别的蚂蚁，还有信息素，信息素有两种，一种是找到食物的蚂蚁洒下的食物信息素，一种是找到窝的蚂蚁洒下的窝的信息素。每个蚂蚁都仅仅能感知它范围内的环境信息。环境以一定的速率让信息素消失。
3、觅食规则
在每只蚂蚁能感知的范围内寻找是否有食物，如果有就直接过去。否则看是否有信息素，并且比较在能感知的范围内哪一点的信息素最多，这样，它就朝信息素多的地方走，并且每只蚂蚁都会以小概率犯错误，从而并不是往信息素最多的点移动。蚂蚁找窝的规则和上面一样，只不过它对窝的信息素做出反应，而对食物信息素没反应。
4、移动规则
每只蚂蚁都朝向信息素最多的方向移，并且，当周围没有信息素指引的时候，蚂蚁会按照自己原来运动的方向惯性的运动下去，并且，在运动的方向有一个随机的小的扰动。为了防止蚂蚁原地转圈，它会记住刚才走过了哪些点，如果发现要走的下一点已经在之前走过了，它就会尽量避开。
5、避障规则
如果蚂蚁要移动的方向有障碍物挡住，它会随机的选择另一个方向，并且有信息素指引的话，它会按照觅食的规则行为。
6、信息素规则
每只蚂蚁在刚找到食物或者窝的时候撒发的信息素最多，并随着它走远的距离，播撒的信息素越来越少。
根据这几条规则，蚂蚁之间并没有直接的关系，但是每只蚂蚁都和环境发生交互，而通过信息素这个纽带，实际上把各个蚂蚁之间关联起来了。比如，当一只蚂蚁找到了食物，它并没有直接告诉其它蚂蚁这儿有食物，而是向环境播撒信息素，当其它的蚂蚁经过它附近的时候，就会感觉到信息素的存在，进而根据信息素的指引找到了食物。
package com.heng;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;
public class Main {
public static void main(String[] args) {
ACO aco;
aco = new ACO();
try {
aco.init("MyFile//eil51.tsp", 50);
long start = System.currentTimeMillis();
aco.run(2000);
aco.ReportResult();
long end = System.currentTimeMillis();
System.out.println("耗时："+(end-start));
} catch (FileNotFoundException ex) {
Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
} catch (IOException ex) {
Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
package com.heng;
import java.io.*;
/**
*蚁群优化算法，用来求解TSP问题
*/
public class ACO {
// 定义蚂蚁群
Ant[] ants;
int antcount;// 蚂蚁的数量
int[][] distance;// 表示城市间距离
double[][] tao;// 信息素矩阵
int citycount;// 城市数量
int[] besttour;// 求解的最佳路径
int bestlength;// 求的最优解的长度
/**
* 初始化函数
* @param filename tsp数据文件
* @param antnum 系统用到蚂蚁的数量
* @throws 如果文件不存在则抛出异常
*/
public void init(String filename, int antnum) throws FileNotFoundException,
IOException {
antcount = antnum;//系统用到的蚂蚁数目
ants = new Ant[antcount];
// 读取数据
int[] x;
int[] y;
String strbuff;
BufferedReader tspdata = new BufferedReader(new InputStreamReader(
new FileInputStream(filename)));
strbuff = tspdata.readLine();//48
System.out.println("strbuff = "+strbuff);
citycount = Integer.valueOf(strbuff);
distance = new int[citycount][citycount];
x = new int[citycount];
y = new int[citycount];
for (int citys = 0; citys < citycount; citys++) {
strbuff = tspdata.readLine();
String[] strcol = strbuff.split(" ");
x[citys] = Integer.valueOf(strcol[1]);
y[citys] = Integer.valueOf(strcol[2]);
}
// 计算距离矩阵
for (int city1 = 0; city1 < citycount - 1; city1++) {
distance[city1][city1] = 0;
for (int city2 = city1 + 1; city2 < citycount; city2++) {
distance[city1][city2] = (int) (Math.sqrt((x[city1] - x[city2])
* (x[city1] - x[city2]) + (y[city1] - y[city2])
* (y[city1] - y[city2])) + 0.5);
distance[city2][city1] = distance[city1][city2];
}
}
distance[citycount - 1][citycount - 1] = 0;
// 初始化信息素矩阵
tao = new double[citycount][citycount];
for (int i = 0; i < citycount; i++) {
for (int j = 0; j < citycount; j++) {
tao[i][j] = 0.1;
}
}
bestlength = Integer.MAX_VALUE;
besttour = new int[citycount + 1];
// 随机放置蚂蚁
for (int i = 0; i < antcount; i++) {
ants[i] = new Ant();
ants[i].RandomSelectCity(citycount);
}
tspdata.close();
}
/**
* ACO的运行过程
* @param maxgen ACO的最多循环次数
*/
public void run(int maxgen) {
for (int runtimes = 0; runtimes < maxgen; runtimes++) {
// 每一只蚂蚁移动的过程
for (int i = 0; i < antcount; i++) {
for (int j = 1; j < citycount; j++) {
ants[i].SelectNextCity(j, tao, distance);
}
// 计算蚂蚁获得的路径长度
ants[i].CalTourLength(distance);
if (ants[i].tourlength < bestlength) {
// 保留最优路径
bestlength = ants[i].tourlength;
System.out.println("第" + runtimes + "代，发现新的解" + bestlength);
for (int j = 0; j < citycount + 1; j++)
besttour[j] = ants[i].tour[j];
}
}
// 更新信息素矩阵
UpdateTao();
// 重新随机设置蚂蚁
for (int i = 0; i < antcount; i++) {
ants[i].RandomSelectCity(citycount);
}
}
}
/**
* 更新信息素矩阵
*/
private void UpdateTao() {
double rou = 0.5;
// 信息素挥发
for (int i = 0; i < citycount; i++)
for (int j = 0; j < citycount; j++)
tao[i][j] = tao[i][j] * (1 - rou);
// 信息素更新
for (int i = 0; i < antcount; i++) {
for (int j = 0; j < citycount; j++) {
tao[ants[i].tour[j]][ants[i].tour[j + 1]] += 1.0 / ants[i].tourlength;
}
}
}
/**
* 输出程序运行结果
*/
public void ReportResult() {
System.out.println("最优路径长度是" + bestlength);
}
}
package com.heng;
import java.util.Random;
/**
* 蚂蚁类
*/
public class Ant {
/**
* 蚂蚁获得的路径
*/
public int[] tour;
// unvisitedcity 取值是0或1，
// 1表示没有访问过，0表示访问过
int[] unvisitedcity;
/**
* 蚂蚁获得的路径长度
*/
public int tourlength;
int citys;
/**
* 随机分配蚂蚁到某个城市中 同时完成蚂蚁包含字段的初始化工作
* @param citycount 总的城市数量
*/
public void RandomSelectCity(int citycount) {
citys = citycount;
unvisitedcity = new int[citycount];
tour = new int[citycount + 1];
tourlength = 0;
for (int i = 0; i < citycount; i++) {
tour[i] = -1;
unvisitedcity[i] = 1;
}
long r1 = System.currentTimeMillis();
Random rnd = new Random(r1);
int firstcity = rnd.nextInt(citycount);
unvisitedcity[firstcity] = 0;
tour[0] = firstcity;
}
/**
* 选择下一个城市
* @param index 需要选择第index个城市了
* @param tao 全局的信息素信息
* @param distance 全局的距离矩阵信息
*/
public void SelectNextCity(int index, double[][] tao, int[][] distance) {
double[] p;
p = new double[citys];
double alpha = 1.0;
double beta = 2.0;
double sum = 0;
int currentcity = tour[index - 1];
// 计算公式中的分母部分
for (int i = 0; i < citys; i++) {
if (unvisitedcity[i] == 1)
sum += (Math.pow(tao[currentcity][i], alpha) * Math.pow(
1.0 / distance[currentcity][i], beta));
}
// 计算每个城市被选中的概率
for (int i = 0; i < citys; i++) {
if (unvisitedcity[i] == 0)
p[i] = 0.0;
else {
p[i] = (Math.pow(tao[currentcity][i], alpha) * Math.pow(
1.0 / distance[currentcity][i], beta)) / sum;
}
}
long r1 = System.currentTimeMillis();
Random rnd = new Random(r1);
double selectp = rnd.nextDouble();
// 轮盘赌选择一个城市；
double sumselect = 0;
int selectcity = -1;
for (int i = 0; i < citys; i++) {
sumselect += p[i];
if (sumselect >= selectp) {
selectcity = i;
break;
}
}
if (selectcity == -1)
System.out.println();
tour[index] = selectcity;
unvisitedcity[selectcity] = 0;
}
/**
* 计算蚂蚁获得的路径的长度
* @param distance 全局的距离矩阵信息
*/
public void CalTourLength(int[][] distance) {
tourlength = 0;
tour[citys] = tour[0];
for (int i = 0; i < citys; i++) {
tourlength += distance[tour[i]][tour[i + 1]];
}
}
}
案例代码下载：http://download.csdn.net/detail/u013043346/9327251