蚁群算法求解TSP问题

最新推荐文章于 2023-05-28 21:21:55 发布
最新推荐文章于 2023-05-28 21:21:55 发布
阅读量221 收藏 1
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_46891664/article/details/116353347
版权 
package ZhiXinGeGe.ServiceImpl;


import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class TSP {
    public static final int m=100;          //蚂蚁总量
    public static final int n=31;           //城市总数
    public static final int NC_max=100;     //最大迭代次数
    public static final double Alpha=1;     //象征信息素重要程度的参数
    public static final double Beta=5;      //象征启发式因子重要程度的参数
    public static final double Rho=0.1;     //信息素蒸发系数
    public static final double Q=100;       //信息素增加强度系数（另一种翻译为信息素总量）
    public static final double C[][]        //城市经纬度存储
            =new double[][]{
            { 1304, 2312 },
            { 3639, 1315 },
            { 4177, 2244 },
            { 3712, 1399 },
            { 3488, 1535 },
            { 3326, 1556 },
            { 3238, 1229 },
            { 4196, 1004 },
            { 4312, 790 },
            { 4386, 570 },
            { 3007, 1970 },
            { 2562, 1756 },
            { 2788, 1491 },
            { 2381, 1676 },
            { 1332, 695 },
            { 3715, 1678 },
            { 3918, 2179 },
            { 4061, 2370 },
            { 3780, 2212 },
            { 3676, 2578 },
            { 4029, 2838 },
            { 4263, 2931 },
            { 3429, 1908 },
            { 3507, 2367 },
            { 3394, 2643 },
            { 3439, 3201 },
            { 2935, 3240 },
            { 3140, 3550 },
            { 2545, 2357 },
            { 2778, 2826 },
            { 2370, 2975 }
        };

    static double D[][]=new double[n][n];          //表示完全图的邻接矩阵
    static double Eta[][]=new double[n][n];        //表示启发式因子，为D中的距离的倒数
    static double DeltaTau[][]=new double[n][n];   //表示启发式因子的变化量
    static double Tau[][]=new double[n][n];        //路径上面信息素的浓度
    static int Tabu[][]=new int[m][n];             //禁忌表，存储走过的路径，一维存第几只蚂蚁，二维存该蚂蚁已经走过的路

    static double L_best[]=new double[NC_max];     //存储每次迭代的路径的最短长度
    static double L_ave[]=new double[NC_max];      //存储每次迭代的路径的平均长度
    static int R_best[][]=new int[NC_max][n];      //存储每次迭代的最佳路线

    public static void ValueInit(){                       //初始化各个参数
        for (int i=0;i<n;i++){              //初始化D：表示完全图的邻接矩阵
            for (int j=0;j<n;j++){
                if (i!=j)
                    D[i][j]=Math.pow(Math.pow((C[i][0]-C[j][0]),2)+Math.pow((C[i][1]-C[j][1]),2),0.5);//勾股定理
                else
                    D[i][j]=0.000000000000000000001;//应该为0，但后面要取倒数
            }
        }

        for (int i=0;i<n;i++)               //初始化Eta：表示启发式因子，为D中距离的倒数
            for (int j=0;j<n;j++)
                Eta[i][j]=1.0/D[i][j];

        for (int i=0;i<n;i++)               //初始化DeltaTau：表示启发式因子的变化量
            for (int j=0;j<n;j++)
                DeltaTau[i][j]=0;

        for (int i=0;i<n;i++)               //初始化Tau：表示路径上的信息素浓度
            for (int j=0;j<n;j++)
                Tau[i][j]=1.0;

        for (int i=0;i<m;i++)               //初始化Tabu：禁忌表
            for (int j=0;j<n;j++)
                Tabu[i][j]=0;
    }
    /**
    void ValueDisplayTabu(int p[][]){       //禁忌表显示函数
        for (int i=0;i<m;i++)
            for (int j=0;j<n;j++)
                System.out.println();
    }
    */

    /**
     void ValueDisplayTau(int p[][]){       //信息素浓度显示函数
     for (int i=0;i<m;i++)
     for (int j=0;j<n;j++)
     System.out.println();
     }
     */

    public static double rnd(double lower,double uper){                   //生成lower和uper之间的一个double类型的随机数
        int max=100,min=1;
        long randomNum = System.currentTimeMillis();        //方法返回从1970年1月1日0时0分0秒（这与UNIX系统有关）到现在的一个long型的毫秒数，取模之后即可得到所需范围内的随机数。
        int ran = (int) (randomNum%(max-min)+min);
        return (ran/(double)max)*(uper-lower)+lower;
    }
    public static void main(String[] args){
        ValueInit();                                        //第一步：进行变量的初始化
        int NC=0;                                           //初始化迭代次数、
        while (NC<NC_max){
            List<Integer> temp=new ArrayList<>();            //第二步：将m只蚂蚁随机的放在n个城市上
            for (int i=0;i<Math.ceil((double)m/(double)n);i++)
                for (int j=0;j<n;j++)
                    temp.add(j);                            //从后部插入

            Collections.shuffle(temp);                      //打乱list里的元素次序

            for (int i=0;i<m;i++)
                Tabu[i][0]=temp.get(i);                     //禁忌表，记录每只蚂蚁出生城市

            for(int j=1;j<n;j++){                           //因为出生在一个城市，所以j从1开始到n
                for (int i=0;i<m;i++){
                    List<Integer> visited=new ArrayList<>();//第i只蚂蚁已访问过的城市
                    List<Integer> J=new ArrayList<>();      //第i只蚂蚁待访问的城市
                    List<Double> P=new ArrayList<>();       //第i只蚂蚁带访问的城市的概率

                    double Psum=0.0;                        //概率值和
                    double rate=0.0;                        //随机数
                    double choose=0.0;                      //轮盘赌算法累加值
                    int to_visit;                           //下一个要去的城市

                    for (int k=0;k<j;k++)
                        visited.add(Tabu[i][k]);            //初始化visited

                    for (int k=0;k<n;k++){
                        if (visited.indexOf(k)==-1){        //在visited里查找k有没有被访问，若没有返回-1
                            J.add(k);                       //J初始化
                            P.add(0.0);                     //P初始化
                        }
                    }

                    for (int k=0;k<P.size();k++){           //计算去下一个城市的概率
                        P.set(k,Math.pow(Tau[visited.get(visited.size()-1)][J.get(k)],Alpha)*Math.pow(Eta[visited.get(visited.size()-1)][J.get(k)],Beta));
                        Psum+=P.get(k);
                    }

                    rate=rnd(0.0,Psum);               //使用轮盘赌算法，挑选下一个要去的城市

                    to_visit=-1;                            //解除java报警
                    for (int k=0;k<P.size();k++){
                        choose+=P.get(k);
                        if (choose>rate){
                            to_visit=J.get(k);
                            break;
                        }
                    }
                    if (to_visit==-1)
                        System.out.println("to_visit未被赋值");
                    else
                        Tabu[i][j]=to_visit;                 //更新禁忌表
                }
            }

            //第四步：记录本次迭代蚂蚁行走的路线数据
            double L[]=new double[m];                        //记录本代每只蚂蚁走的路程，并初始化
            for (int i=0;i<n;i++){
                L[i]=0.0;
            }
            for (int i=0;i<m;i++){
                for (int j=0;j<n-1;j++){
                    L[i]+=D[Tabu[i][j]][Tabu[i][j+1]];
                }
                L[i]+=D[Tabu[i][0]][Tabu[i][n-1]];          //最后终点到起点
            }
            double min_value=L[0];                          //声明本代所有蚂蚁行走距离最小值的临时变量
            double sum_value=L[0];                          //声明本代所有蚂蚁行走距离总值的临时变量
            int min_index=0;                                //记录本代所有蚂蚁行走距离最小值的下标
            for (int i=1;i<m;i++){
                sum_value+=L[i];
                if (L[i]<min_value){
                    min_value=L[i];
                    min_index=i;
                }
            }
            L_best[NC]=min_value;                           //每代路径的最短长度
            L_ave[NC]=sum_value/m;                          //每代路径的平均长度

            for (int i=0;i<n;i++){
                R_best[NC][i]=Tabu[min_index][i];           //记录每代最短的路径数据
            }

            System.out.println(NC+":L_best is "+L_best[NC]+"  L_ave is "+L_ave[NC]);

            NC++;                                           //迭代继续

            //第五步：更新信息素
            for (int i=0;i<m;i++){
                for (int j=0;j<n-1;j++){
                    DeltaTau[Tabu[i][j]][Tabu[i][j+1]]+=Q/L[i];//此次循环在整个路径上的信息素增量
                }
                DeltaTau[Tabu[i][n-1]][Tabu[i][0]]+=Q/L[i];
            }

            for (int i=0;i<n;i++){
                for (int j=0;j<n;j++){
                    Tau[i][j]=(1-Rho)*Tau[i][j]+DeltaTau[i][j];//考虑信息素挥发，更新后的信息素
                }
            }

            for (int i=0;i<m;i++)                              //禁忌表清空
                for (int j=0;j<n;j++)
                    Tabu[i][j]=0;

        }

        //第六步：输出结果
        double min_L=L_best[0];
        int min_L_index=0;
        int Shortest_Route[]=new int[n];

        for (int i=0;i<NC;i++){
            if (L_best[i]<min_L){
                min_L=L_best[i];
                min_L_index=i;
            }
        }
        System.out.println( "The length of the shortest route is " + min_L );
        System.out.println("The number of iteration is " + min_L_index);
        System.out.println("The Shortest route is： ");
        System.out.print("start");
        for (int i=0;i<n;i++){
            Shortest_Route[i]=R_best[min_L_index][i];
            System.out.print("->"+Shortest_Route[i]);
        }
    }

}
chinaPug
关注
蚁群算法求解TSP
BeyondWang的博客
04-15 941
蚁群算法 蚁群算法是一种经典的传统人工智能算法，早在上个世纪90年代就提出了。网络中已经有很多教材与教程，这里不再复述。 推荐《人工智能导论》（第四版），王万良编著，其6.7章节将蚁群算法讲的非常简单清楚。 网上也有很多matlab版本，java版本的蚁群算法模板。 笔者周日为了练习编码能力，完成了python版本的蚁群算法。文末附上github开源代码网址，项目中有测试样例与实验数据。 参数 ...
蚁群算法tsp求解
Allen1862105的博客
12-13 439
TSP问题（Travel Salesperson Problem，即旅行商问题或者称为中国邮递员问题），是一种NP-hard问题，此类问题用一般的算法是很难得到最优解的，所以一般需要借助一些启发式算法求解，例如遗传算法（GA），蚁群算法（ACO），微粒群算法（PSO）等等。蚁群算法最早用来求解TSP问题，并且表现出了很大的优越性，因为它分布式特性，鲁棒性强并且容易与其它算法结合，但是同时也存在这收敛速度慢，容易陷入局部最优（local optimal）等缺点。需要数据的话可以后台私信我。
Matlab蚁群算法求解TSP问题实例代码（带注释）
04-20
【Matlab蚁群算法求解TSP问题实例代码（带注释）】 旅行商问题（Traveling Salesman Problem，简称TSP）是一个经典的组合优化问题，它询问的是一个旅行商如何访问n个城市，并且每个城市只访问一次，然后返回起点，...
MATLAB源码集锦-蚁群算法求解TSP问题matlab代码
02-14
在本例中，MATLAB被用来实现蚁群算法求解TSP问题的代码编写。 MATLAB代码实现的关键步骤如下： 1. **初始化**：设定城市数量、蚂蚁数量、信息素蒸发率、信息素更新权重、启发式因子等参数。 2. **构建图**：创建...
蚁群算法求解TSP问题.rar_TSP蚁群算法_TSP问题_蚁群算法 tsp_蚁群算法TSP_路线
07-15
《蚁群算法求解TSP问题》 旅行商问题（Traveling Salesman Problem，简称TSP）是一个经典的组合优化问题，其目标是寻找最短的可能路径，使得旅行商能够访问每个城市一次并返回起点。这是一个著名的NP完全问题，意味...
蚁群算法求解tsp 问题
05-07
使用 蚁群算法求解tsp 问题 运行程序时选择后缀为tsp的文件加载
用蚁群算法解决TSP问题
06-20
详细展示链接：https://blog.youkuaiyun.com/qq_35685675/article/details/80740609
蚁群算法解决TSP完整代码
05-31
详情 https://blog.youkuaiyun.com/qq_26769591/article/details/80530398
数学建模源码集锦-蚁群算法的优化计算——旅行商问题(TSP)优化应用实例
03-12
数学建模源码集锦-蚁群算法的优化计算——旅行商问题(TSP)优化应用实例
基本蚁群算法求解TSP的cpp实现
05-13
基本蚁群算法求解TSP的cpp实现 基本蚁群算法求解TSP的cpp实现
蚁群算法（解决TSP问题）
qq_45874683的博客
05-28 1万+
蚂蚁在寻找食物源时，会在其经过的路径上释放一种信息素，并能够感知其它蚂蚁释放的信息素。信息素浓度的大小表征到食物源路径的远近，信息素浓度越高，表示对应的路径距离越短。通常，蚂蚁会以较大的概率优先选择信息素浓度较高的路径，并释放一定量的信息素，以增强该条路径上的信息素浓度，这样会形成一个正反馈。最终，蚂蚁能够找到一条从巢穴到食物源的最佳路径，即最短距离。值得一提的是，生物学家同时发现，路径上的信息素浓度会随着时间的推进而逐渐衰减。
蚁群算法解决TSP问题
tangjian_1314的专栏
09-17 3122
首先，旅行商问题，即TSP问题（Traveling Salesman Problem）又译为旅行推销员问题、货郎担问题，是数学领域中著名问题之一。假设有一个旅行商人要拜访n个城市，他必须选择所要走的路径，路径的限制是每个城市只能拜访一次，而且最后要回到原来出发的城市。路径的选择目标是要求得的路径路程为所有路径之中的最小值。（摘自百度百科） 然后，蚁群算法，是一种用来寻找优化路径的概率型算法。它由...
蚁群算法求解TSP问题（Python实现）
xiaomin_549的博客
12-12 7252
算法简介 蚁群系统(Ant System或Ant Colony System)是由意大利学者Dorigo、Maniezzo等人于20世纪90年代首先提出来的。他们在研究蚂蚁觅食的过程中，发现单个蚂蚁的行为比较简单，但是蚁群整体却可以体现一些智能的行为。例如蚁群可以在不同的环境下，寻找最短到达食物源的路径。这是因为蚁群内的蚂蚁可以通过某种信息机制实现信息的传递。后又经进一步研究发现，蚂蚁会在其经过的路径上释放一种可以称之为“信息素”的物质，蚁群内的蚂蚁对“信息素”具有感知能力，它们会沿着“...
【路径规划】基于蚁群算法求解TSP问题
m0_60703264的博客
08-16 4539
​问题定义：巡回旅行商问题 给定一组n个城市和俩俩之间的直达距离，寻找一条闭合的旅程，使得每个城市刚好经过一次且总的旅行距离最短。TSP问题也称为货郎担问题，是一个古老的问题。最早可以追溯到1759年Euler提出的骑士旅行的问题。1948年，由美国兰德公司推动，TSP成为近代组合优化领域的典型难题。TSP是一个具有广泛的应用背景和重要理论价值的组合优化问题。近年来，有很多解决该问题的较为有效的算法不断被推出，例如Hopfield神经网络方法，模拟退火方法以及遗传算法方法等。TSP搜索空间随着城市数n的.
蚁群算法求解TSP问题的毕业设计资料整理
蚁群算法在求解TSP问题中的应用主要是因为它具有很强的全局搜索能力、并行性、鲁棒性和易于与其他算法结合等特点。算法的基本原理如下： 1. 初始化：首先，根据问题的规模和特性设定蚂蚁数量，初始化信息素矩阵。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值