- 浏览: 192000 次
- 性别:
- 来自: 长沙
文章分类
最新评论
-
LXX516:
LXX516 写道你好,运行时出现如下问题:E/Trace(1 ...
PC客户端与Android实现图片传送 -
LXX516:
你好,运行时出现如下问题:E/Trace(15019): er ...
PC客户端与Android实现图片传送 -
huzhenyu:
希望各位大顶起,支持国产免费软件
公式编辑器MathMarkEdit1.0发布 -
zhangyou1010:
默认是8000的端口,如果用sh catalina.sh jp ...
使用eclipse远程调试部署在tomcat上的应用程序 -
zhangyou1010:
有时间,也要玩玩QT,哈哈。
Qt Grid布局
From:http://zhidao.baidu.com/question/49867736说明:信息素权重,路径权重和信息素蒸发率对最后的结果影响很大,需要微调。
目前发现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.arraycopy(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;
}
}
}
目前发现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.arraycopy(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;
}
}
}
发表评论
-
CDT JNI
2012-12-01 23:26 772http://www.blogjava.net/orangew ... -
PC客户端与Android实现图片传送
2012-10-16 11:48 6519PC服务端,用于发送图片 import java.io.Dat ... -
h.264
2012-05-30 00:03 1293http://www.elecfans.com/video/a ... -
gxt mvc架构分析
2011-08-18 19:15 928http://www.bristol-gtug.org/?p= ... -
这个表达式你一眼看得出结论来吗?if ((n & -n) == n)
2011-06-09 11:47 913如题,很惭愧本人确实没有一眼看出来.首先定性思维第一反应把&q ... -
tomcat中将项目部署为根目录
2011-03-29 20:50 940修改server.xml <Context debug= ... -
AWT双缓冲,消除闪烁
2011-03-25 11:26 2110以上原文from:http://blog.csdn.net/w ... -
c++学习笔记
2011-02-21 21:48 9901.指针是用来保存内存地址的变量 如:int i; int * ... -
收藏hibernate二级缓存的两篇文章
2011-01-15 23:35 804http://www.iteye.com/topic/1890 ... -
sturts2标签使用说明
2011-01-07 14:27 1130http://www.roseindia.net/struts ... -
java -classpath使用
2011-01-06 22:29 946假设三个类:Dog继承Animal并引用Food那么怎么去执行 ... -
P6spy
2011-01-03 16:50 2707from:http://blog.chinaunix.net/ ... -
oracle修改表增加列删除列修改列
2010-12-28 13:20 2490oracle修改表增加列删除列修改列 1.增加列 ALTER ... -
Java应用程序安装成一个Windows NT服务
2010-12-24 14:22 1001http://wrapper.tanukisoftware.c ... -
play framwork导出war包
2010-12-04 12:42 1106play war myApp -o /myApp --zip -
JAVA静态导入(inport static)详解
2010-12-01 13:40 2092在Java 5中,import语句得到了增强,以便提供甚至更加 ... -
两段copy文件的代码
2010-11-26 09:25 7991.传统的基于IO的Copy方法 import java.io ... -
动态加载jar
2010-11-21 14:39 2799在eclipse中有个自动升级,可以直接通过一个互联上链接安装 ... -
java动态代理入门示例
2010-09-16 22:44 1097package com.huzy.proxy; impo ... -
让windows启动时自动运行bat脚本
2010-06-06 10:46 3258打开组策略运行输入gpedit.msc 用户配置window ...
相关推荐
代码 改进蚁群算法求解连续空间优化问题代码代码 改进蚁群算法求解连续空间优化问题代码代码 改进蚁群算法求解连续空间优化问题代码代码 改进蚁群算法求解连续空间优化问题代码代码 改进蚁群算法求解连续空间优化...
标题中的"matlab蚁群算法工具箱matlab蚁群算法工具箱源代码"指的是一个专门用于MATLAB环境的开源工具箱,它包含了实现蚁群算法的各种函数和脚本,便于研究人员和工程师进行优化问题的求解。这个工具箱通常会包含以下...
【蚁群算法】是模拟自然界中蚂蚁寻找食物过程的一种优化算法,属于群体智能算法的一种,广泛应用于路径规划、网络路由、组合优化问题等。在人工智能领域,蚁群算法因其并行性和分布式特性,能有效解决复杂问题。 在...
蚁群算法(Ant Colony Optimization, ACO)是一种模拟自然界中蚂蚁寻找食物路径行为的优化算法,由Marco Dorigo在1992年提出。它主要用于解决组合优化问题,如旅行商问题、网络路由问题等。MATLAB作为一款强大的数学...
蚁群算法工具箱蚁群算法资料:蚁群算法工具箱蚁群算法资料:蚁群算法工具箱蚁群算法资料:蚁群算法工具箱蚁群算法资料:蚁群算法工具蚁群算法工具箱蚁群算法资料:箱蚁群算法资料:蚁群算法工具蚁群算法工具箱蚁群...
蚁群算法(Ant Colony Optimization, ACO)是一种模拟生物界蚂蚁寻找食物路径行为的优化算法,广泛应用于路径规划、网络路由、旅行商问题等复杂优化问题。在MATLAB环境中实现蚁群算法,可以借助其强大的矩阵运算能力...
蚁群算法源程序(matlab版本) 蚁群算法是一种基于 Swarm Intelligence 的智能优化算法,通过模拟蚂蚁觅食行为来寻找最短路径。该算法的核心思想是将蚂蚁的觅食行为抽象化,从而找到问题的最优解。在这个 Matlab ...
蚁群算法(Ant Colony Optimization, ACO)是一种模拟生物进化机制的优化算法,源自自然界中蚂蚁寻找食物的行为。蚂蚁在寻找食物过程中会释放信息素,其他蚂蚁会根据这些信息素的浓度选择路径,最终形成一个高效的...
蚁群算法(Ant Colony Optimization, ACO)是一种借鉴自然界中蚂蚁寻找食物路径行为的优化算法,它在解决组合优化问题,如旅行商问题、车辆路径问题以及本例中的车间调度问题中表现出强大的潜力。 在“基于蚁群算法...
标题中的“ACOsecond.rar_ACOsecond_bandrb9_固定起点固定终点ACO代码_蚁群算法_蚁群算法终点”表明这是一个关于蚁群算法(Ant Colony Optimization, ACO)的程序代码,其中包含了特定的优化问题解决方案,即固定...
本文档集中讨论了一种创新方法——基于蚁群算法的图像边缘检测技术,这种技术通过模拟自然界的蚂蚁行为来优化图像的边缘识别过程。 首先,蚁群算法(Ant Colony Optimization, ACO)源于生物学家对蚂蚁寻找食物路径...
蚁群算法(Ant Colony Optimization,简称ACO)是一种启发式搜索算法,受蚁群在寻找食物过程中的行为启发而提出。蚁群算法通常用于解决组合优化问题,例如旅行商问题(TSP)、车辆路径问题、作业调度等。 蚁群算法...
《蚁群算法在栅格地图上实现最短距离的MATLAB应用详解》 蚁群算法,作为一种模拟自然界的群体智能优化方法,近年来在路径规划问题中得到了广泛应用。它源自于蚂蚁寻找食物过程中发现路径的行为,通过模拟蚂蚁在路径...
蚁群算法(Ant Colony Optimization, ACO)是一种模拟生物界中蚂蚁寻找食物行为的优化算法,主要用于解决组合优化问题,如图的最短路径搜索。在这个场景中,它被应用于栅格地图上的路径规划,旨在找到从起点到终点的...
蚁群算法是一种模拟生物群体行为的优化算法,源自对蚂蚁寻找食物过程中发现路径的行为的研究。在蚁群系统中,每只蚂蚁在环境中留下一种称为信息素的化学物质,这种信息素随着时间逐渐挥发,同时又被其他蚂蚁在经过时...
蚁群算法是一种模拟自然界蚂蚁寻找食物行为的优化算法,由Marco Dorigo于1992年提出。这种算法基于蚂蚁在寻找食物过程中通过释放信息素来通信和合作的生物现象,将其应用于解决复杂的数学问题,如最优化、路径规划等...
蚁群算法,是一种模拟自然界蚂蚁寻找食物路径行为的优化算法,由Marco Dorigo于1992年提出。这种算法基于群体智能的概念,通过个体之间的简单交互来解决复杂问题,如旅行商问题(TSP)。在TSP中,蚁群算法的目标是...
蚁群算法的原理分析及算法描述,, 蚂蚁的信息系统,, 蚁群社会的遗传和进化,, 蚂蚁的觅食行为和觅食策略,, 蚂蚁的觅食行为,, 蚂蚁的觅食策略,, 蚁群算法的原理分析,, 人工蚁群算法的算法描述,, 人工蚁和真实蚂蚁的异同...
蚁群算法是一种模拟蚂蚁觅食行为的启发式算法,它主要通过群体协作来寻找问题的最优解。该算法由Marco Dorigo在1992年提出,最初应用于解决旅行商问题(TSP),后来逐渐发展和应用到各种优化问题中。蚁群算法属于蚁...
蚁群算法(Ant Colony Optimization,ACO)是一种基于生物启发式优化的计算方法,它模拟了蚂蚁寻找食物路径的过程来解决复杂问题。 蚁群算法的核心思想是通过虚拟蚂蚁在解空间中探索最优路径,并利用信息素(一种...