ACO蚁群算法解决TSP旅行商问题

前言

蚁群算法也是一种利用了大自然规律的启发式算法，与之前学习过的GA遗传算法类似，遗传算法是用了生物进行理论，把更具适应性的基因传给下一代，最后就能得到一个最优解，常常用来寻找问题的最优解。当然，本篇文章不会主讲GA算法的，想要了解的同学可以查看，我的遗传算法学习和遗传算法在走迷宫中的应用。话题重新回到蚁群算法，蚁群算法是一个利用了蚂蚁寻找食物的原理。不知道小时候有没有发现，当一个蚂蚁发现了地上的食物，然后非常迅速的，就有其他的蚂蚁聚拢过来，最后把食物抬回家，这里面其实有着非常多的道理的，在ACO中就用到了这个机理用于解决实际生活中的一些问题。

蚂蚁找食物

首先我们要具体说说一个有意思的事情，就是蚂蚁找食物的问题，理解了这个原理之后，对于理解ACO算法就非常容易了。蚂蚁作为那么小的动物，在地上漫无目的的寻找食物，起初都是没有目标的，他从蚂蚁洞中走出，随机的爬向各个方向，在这期间他会向外界播撒一种化学物质，姑且就叫做信息素，所以这里就可以得到的一个前提，越多蚂蚁走过的路径，信息素浓度就会越高，那么某条路径信息素浓度高了，自然就会有越多的蚂蚁感觉到了，就会聚集过来了。所以当众多蚂蚁中的一个找到食物之后，他就会在走过的路径中放出信息素浓度，因此就会有很多的蚂蚁赶来了。类似下面的场景：

至于蚂蚁是如何感知这个信息素，这个就得问生物学家了，我也没做过研究。

算法介绍

OK，有了上面这个自然生活中的生物场景之后，我们再来切入文章主题来学习一下蚁群算法，百度百科中对应蚁群算法是这么介绍的：蚁群算法是一种在图中寻找优化路径的机率型算法。他的灵感就是来自于蚂蚁发现食物的行为。蚁群算法是一种新的模拟进化优化的算法，与遗传算法有很多相似的地方。蚁群算法在比较早的时候成功解决了TSP旅行商的问题（在后面的例子中也会以这个例子）。要用算法去模拟蚂蚁的这种行为，关键在于信息素的在算法中的设计，以及路径中信息素浓度越大的路径，将会有更高的概率被蚂蚁所选择到。

算法原理

要想实现上面的几个模拟行为，需要借助几个公式，当然公式不是我自己定义的，主要有3个，如下图：

上图中所出现的alpha，beita，p等数字都是控制因子，所以可不必理会，Tij(n)的意思是在时间为n的时候，从城市i到城市j的路径的信息素浓度。类似于nij的字母是城市i到城市j距离的倒数。就是下面这个公式。

所以所有的公式都是为第一个公式服务的，第一个公式的意思是指第k只蚂蚁选择从城市i到城市j的概率，可以见得，这个受距离和信息素浓度的双重影响，距离越远，去此城市的概率自然也低，所以nij会等于距离的倒数，而且在算信息素浓度的时候，也考虑到了信息素浓度衰减的问题，所以会在上次的浓度值上乘以一个衰减因子P。另外还要加上本轮搜索增加的信息素浓度（假如有蚂蚁经过此路径的话），所以这几个公式的整体设计思想还是非常棒的。

算法的代码实现

由于本身我这里没有什么真实的测试数据，就随便自己构造了一个简单的数据，输入如下，分为城市名称和城市之间的距离，用#符号做区分标识，大家应该可以看得懂吧

# CityName
1
2
3
4
# Distance
1 2 1
1 3 1.4
1 4 1
2 3 1
2 4 1
3 4 1

蚂蚁类Ant.java:

package DataMining_ACO;

import java.util.ArrayList;

/**
 * 蚂蚁类，进行路径搜索的载体
 * 
 * @author lyq
 * 
 */
public class Ant implements Comparable<Ant> {
// 蚂蚁当前所在城市
String currentPos;
// 蚂蚁遍历完回到原点所用的总距离
Double sumDistance;
// 城市间的信息素浓度矩阵，随着时间的增多而减少
double[][] pheromoneMatrix;
// 蚂蚁已经走过的城市集合
ArrayList<String> visitedCitys;
// 还未走过的城市集合
ArrayList<String> nonVisitedCitys;
// 蚂蚁当前走过的路径
ArrayList<String> currentPath;

public Ant(double[][] pheromoneMatrix, ArrayList<String> nonVisitedCitys) {
this.pheromoneMatrix = pheromoneMatrix;
this.nonVisitedCitys = nonVisitedCitys;

this.visitedCitys = new ArrayList<>();
this.currentPath = new ArrayList<>();
}

/**
 * 计算路径的总成本(距离)
 * 
 * @return
 */
public double calSumDistance() {
sumDistance = 0.0;
String lastCity;
String currentCity;

for (int i = 0; i < currentPath.size() - 1; i++) {
lastCity = currentPath.get(i);
currentCity = currentPath.get(i + 1);

// 通过距离矩阵进行计算
sumDistance += ACOTool.disMatrix[Integer.parseInt(lastCity)][Integer
.parseInt(currentCity)];
}

return sumDistance;
}

/**
 * 蚂蚁选择前往下一个城市
 * 
 * @param city
 *            所选的城市
 */
public void goToNextCity(String city) {
this.currentPath.add(city);
this.currentPos = city;
this.nonVisitedCitys.remove(city);
this.visitedCitys.add(city);
}

/**
 * 判断蚂蚁是否已经又重新回到起点
 * 
 * @return
 */
public boolean isBack() {
boolean isBack = false;
String startPos;
String endPos;

if (currentPath.size() == 0) {
return isBack;
}

startPos = currentPath.get(0);
endPos = currentPath.get(currentPath.size() - 1);
if (currentPath.size() > 1 && startPos.equals(endPos)) {
isBack = true;
}

return isBack;
}

/**
 * 判断蚂蚁在本次的走过的路径中是否包含从城市i到城市j
 * 
 * @param cityI
 *            城市I
 * @param cityJ
 *            城市J
 * @return
 */
public boolean pathContained(String cityI, String cityJ) {
String lastCity;
String currentCity;
boolean isContained = false;

for (int i = 0; i < currentPath.size() - 1; i++) {
lastCity = currentPath.get(i);
currentCity = currentPath.get(i + 1);

// 如果某一段路径的始末位置一致，则认为有经过此城市
if ((lastCity.equals(cityI) && currentCity.equals(cityJ))
|| (lastCity.equals(cityJ) && currentCity.equals(cityI))) {
isContained = true;
break;
}
}

return isContained;
}

@Override
public int compareTo(Ant o) {
// TODO Auto-generated method stub
return this.sumDistance.compareTo(o.sumDistance);
}
}

蚁群算法工具类ACOTool.java:

package DataMining_ACO;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;

/**
 * 蚁群算法工具类
 * 
 * @author lyq
 * 
 */
public class ACOTool {
// 输入数据类型
public static final int INPUT_CITY_NAME = 1;
public static final int INPUT_CITY_DIS = 2;

// 城市间距离邻接矩阵
public static double[][] disMatrix;
// 当前时间
public static int currentTime;

// 测试数据地址
private String filePath;
// 蚂蚁数量
private int antNum;
// 控制参数
private double alpha;
private double beita;
private double p;
private double Q;
// 随机数产生器
private Random random;
// 城市名称集合,这里为了方便，将城市用数字表示
private ArrayList<String> totalCitys;
// 所有的蚂蚁集合
private ArrayList<Ant> totalAnts;
// 城市间的信息素浓度矩阵，随着时间的增多而减少
private double[][] pheromoneMatrix;
// 目标的最短路径,顺序为从集合的前部往后挪动
private ArrayList<String> bestPath;
// 信息素矩阵存储图,key采用的格式(i,j,t)->value
private Map<String, Double> pheromoneTimeMap;

public ACOTool(String filePath, int antNum, double alpha, double beita,
double p, double Q) {
this.filePath = filePath;
this.antNum = antNum;
this.alpha = alpha;
this.beita = beita;
this.p = p;
this.Q = Q;
this.currentTime = 0;

readDataFile();
}

/**
 * 从文件中读取数据
 */
private void readDataFile() {
File file = new File(filePath);
ArrayList<String[]> dataArray = new ArrayList<String[]>();

try {
BufferedReader in = new BufferedReader(new FileReader(file));
String str;
String[] tempArray;
while ((str = in.readLine()) != null) {
tempArray = str.split(" ");
dataArray.add(tempArray);
}
in.close();
} catch (IOException e) {
e.getStackTrace();
}

int flag = -1;
int src = 0;
int des = 0;
int size = 0;
// 进行城市名称种数的统计
this.totalCitys = new ArrayList<>();
for (String[] array : dataArray) {
if (array[0].equals("#") && totalCitys.size() == 0) {
flag = INPUT_CITY_NAME;

continue;
} else if (array[0].equals("#") && totalCitys.size() > 0) {
size = totalCitys.size();
// 初始化距离矩阵
this.disMatrix = new double[size + 1][size + 1];
this.pheromoneMatrix = new double[size + 1][size + 1];

// 初始值-1代表此对应位置无值
for (int i = 0; i < size; i++) {
for (int j = 0; j < size; j++) {
this.disMatrix[i][j] = -1;
this.pheromoneMatrix[i][j] = -1;
}
}

flag = INPUT_CITY_DIS;
continue;
}

if (flag == INPUT_CITY_NAME) {
this.totalCitys.add(array[0]);
} else {
src = Integer.parseInt(array[0]);
des = Integer.parseInt(array[1]);

this.disMatrix[src][des] = Double.parseDouble(array[2]);
this.disMatrix[des][src] = Double.parseDouble(array[2]);
}
}
}

/**
 * 计算从蚂蚁城市i到j的概率
 * 
 * @param cityI
 *            城市I
 * @param cityJ
 *            城市J
 * @param currentTime
 *            当前时间
 * @return
 */
private double calIToJProbably(String cityI, String cityJ, int currentTime) {
double pro = 0;
double n = 0;
double pheromone;
int i;
int j;

i = Integer.parseInt(cityI);
j = Integer.parseInt(cityJ);

pheromone = getPheromone(currentTime, cityI, cityJ);
n = 1.0 / disMatrix[i][j];

if (pheromone == 0) {
pheromone = 1;
}

pro = Math.pow(n, alpha) * Math.pow(pheromone, beita);

return pro;
}

/**
 * 计算综合概率蚂蚁从I城市走到J城市的概率
 * 
 * @return
 */
public String selectAntNextCity(Ant ant, int currentTime) {
double randomNum;
double tempPro;
// 总概率指数
double proTotal;
String nextCity = null;
ArrayList<String> allowedCitys;
// 各城市概率集
double[] proArray;

// 如果是刚刚开始的时候，没有路过任何城市，则随机返回一个城市
if (ant.currentPath.size() == 0) {
nextCity = String.valueOf(random.nextInt(totalCitys.size()) + 1);

return nextCity;
} else if (ant.nonVisitedCitys.isEmpty()) {
// 如果全部遍历完毕，则再次回到起点
nextCity = ant.currentPath.get(0);

return nextCity;
}

proTotal = 0;
allowedCitys = ant.nonVisitedCitys;
proArray = new double[allowedCitys.size()];

for (int i = 0; i < allowedCitys.size(); i++) {
nextCity = allowedCitys.get(i);
proArray[i] = calIToJProbably(ant.currentPos, nextCity, currentTime);
proTotal += proArray[i];
}

for (int i = 0; i < allowedCitys.size(); i++) {
// 归一化处理
proArray[i] /= proTotal;
}

// 用随机数选择下一个城市
randomNum = random.nextInt(100) + 1;
randomNum = randomNum / 100;
// 因为1.0是无法判断到的，,总和会无限接近1.0取为0.99做判断
if (randomNum == 1) {
randomNum = randomNum - 0.01;
}

tempPro = 0;
// 确定区间
for (int j = 0; j < allowedCitys.size(); j++) {
if (randomNum > tempPro && randomNum <= tempPro + proArray[j]) {
// 采用拷贝的方式避免引用重复
nextCity = allowedCitys.get(j);
break;
} else {
tempPro += proArray[j];
}
}

return nextCity;
}

/**
 * 获取给定时间点上从城市i到城市j的信息素浓度
 * 
 * @param t
 * @param cityI
 * @param cityJ
 * @return
 */
private double getPheromone(int t, String cityI, String cityJ) {
double pheromone = 0;
String key;

// 上一周期需将时间倒回一周期
key = MessageFormat.format("{0},{1},{2}", cityI, cityJ, t);

if (pheromoneTimeMap.containsKey(key)) {
pheromone = pheromoneTimeMap.get(key);
}

return pheromone;
}

/**
 * 每轮结束，刷新信息素浓度矩阵
 * 
 * @param t
 */
private void refreshPheromone(int t) {
double pheromone = 0;
// 上一轮周期结束后的信息素浓度，丛信息素浓度图中查找
double lastTimeP = 0;
// 本轮信息素浓度增加量
double addPheromone;
String key;

for (String i : totalCitys) {
for (String j : totalCitys) {
if (!i.equals(j)) {
// 上一周期需将时间倒回一周期
key = MessageFormat.format("{0},{1},{2}", i, j, t - 1);

if (pheromoneTimeMap.containsKey(key)) {
lastTimeP = pheromoneTimeMap.get(key);
} else {
lastTimeP = 0;
}

addPheromone = 0;
for (Ant ant : totalAnts) {
if(ant.pathContained(i, j)){
// 每只蚂蚁传播的信息素为控制因子除以距离总成本
addPheromone += Q / ant.calSumDistance();
}
}

// 将上次的结果值加上递增的量，并存入图中
pheromone = p * lastTimeP + addPheromone;
key = MessageFormat.format("{0},{1},{2}", i, j, t);
pheromoneTimeMap.put(key, pheromone);
}
}
}

}

/**
 * 蚁群算法迭代次数
 * @param loopCount
 * 具体遍历次数
 */
public void antStartSearching(int loopCount) {
// 蚁群寻找的总次数
int count = 0;
// 选中的下一个城市
String selectedCity = "";

pheromoneTimeMap = new HashMap<String, Double>();
totalAnts = new ArrayList<>();
random = new Random();

while (count < loopCount) {
initAnts();

while (true) {
for (Ant ant : totalAnts) {
selectedCity = selectAntNextCity(ant, currentTime);
ant.goToNextCity(selectedCity);
}

// 如果已经遍历完所有城市，则跳出此轮循环
if (totalAnts.get(0).isBack()) {
break;
}
}

// 周期时间叠加
currentTime++;
refreshPheromone(currentTime);
count++;
}

// 根据距离成本，选出所花距离最短的一个路径
Collections.sort(totalAnts);
bestPath = totalAnts.get(0).currentPath;
System.out.println(MessageFormat.format("经过{0}次循环遍历，最终得出的最佳路径：", count));
System.out.print("entrance");
for (String cityName : bestPath) {
System.out.print(MessageFormat.format("-->{0}", cityName));
}
}

/**
 * 初始化蚁群操作
 */
private void initAnts() {
Ant tempAnt;
ArrayList<String> nonVisitedCitys;
totalAnts.clear();

// 初始化蚁群
for (int i = 0; i < antNum; i++) {
nonVisitedCitys = (ArrayList<String>) totalCitys.clone();
tempAnt = new Ant(pheromoneMatrix, nonVisitedCitys);

totalAnts.add(tempAnt);
}
}
}

场景测试类Client.java:

package DataMining_ACO;

/**
 * 蚁群算法测试类
 * @author lyq
 *
 */
public class Client {
public static void main(String[] args){
//测试数据
String filePath = "C:\\Users\\lyq\\Desktop\\icon\\input.txt";
//蚂蚁数量
int antNum;
//蚁群算法迭代次数
int loopCount;
//控制参数
double alpha;
double beita;
double p;
double Q;

antNum = 3;
alpha = 0.5;
beita = 1;
p = 0.5;
Q = 5;
loopCount = 5;

ACOTool tool = new ACOTool(filePath, antNum, alpha, beita, p, Q);
tool.antStartSearching(loopCount);
}
}

算法的输出，就是在多次搜索之后，找到的路径中最短的一个路径：

经过5次循环遍历，最终得出的最佳路径：
entrance-->4-->1-->2-->3-->4

因为数据量比较小，并不能看出蚁群算法在这方面的优势，博友们可以再次基础上自行改造，并用大一点的数据做测试，其中的4个控制因子也可以调控。蚁群算法作为一种启发式算法，还可以和遗传算法结合，创造出更优的算法。蚁群算法可以解决许多这样的连通图路径优化问题。但是有的时候也会出现搜索时间过长的问题。

参考文献：百度百科.蚁群算法

我的数据挖掘算法库：https://github.com/linyiqun/DataMiningAlgorithm

我的算法库：https://github.com/linyiqun/lyq-algorithms-lib