旅行商问题TSP（蚁群算法Java）

最新推荐文章于 2024-09-18 08:54:47 发布
最新推荐文章于 2024-09-18 08:54:47 发布
阅读量2.6k 收藏 12
点赞数 3
分类专栏： Java
旅行商问题，即TSP问题（Traveling Salesman Problem）是数学领域中著名问题之一。假设有一个旅行商人要拜访N个城市，他必须选择所要走的路径，路径的限制是每个城市只能拜访一次，而且最后要 回到原来出发的城市。路径的选择目标是要求得的路径路程为所有路径之中的最小值。TSP问题是一个NPC问题。这个问题一般是使用遗传算法去解,但是蚂蚁算法要更高效.对于c++不熟悉的我,用C语言是个噩梦,因此写一个java代码,并且桌面窗口显示结果的版本.

再来说说蚁群算法

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


公共函数及变量

[java]  view plain  copy
  1. package com.seul.tsp;  
  2. /* 
  3.  * 公共函数以及变量 
  4.  */  
  5. public class PublicFun  
  6. {  
  7.     public static final double ALPHA=1.0;//信息启发式因子，信息素的重要程度  
  8.     public static final double BETA=2.0;//期望启发式因子, 城市间距离的重要程度  
  9.     public static final double ROU=0.5;//信息素残留系数  
  10.    
  11.     public static  int N_ANT_COUNT=50;//蚂蚁数量  
  12.     public static  int N_IT_COUNT=200;//迭代次数  
  13.     public static  int N_CITY_COUNT=15;//城市数量  
  14.    
  15.     public static final double DBQ=100.0;//总信息素  
  16.     public static final double DB_MAX=Math.pow(10,9);//一个标志数,用来初始化一个比较大的最优路径  
  17.       
  18.     //两两城市间的信息量  
  19.     public static double[][] g_Trial;  
  20.       
  21.     //两两城市间的距离  
  22.     public static double[][] g_Distance;  
  23.   
  24.       
  25.     //返回指定范围内的随机整数  
  26.     public static int rnd(int nLow,int nUpper)  
  27.     {  
  28.         return (int) (Math.random()*(nUpper-nLow)+nLow);  
  29.     }  
  30.     //返回指定范围内的随机浮点数  
  31.     public static double rnd(double dbLow,double dbUpper)  
  32.     {  
  33.         return Math.random()*(dbUpper-dbLow)+dbLow;  
  34.     }  
  35.       
  36.       
  37. }  

蚂蚁类

[java]  view plain  copy
  1. package com.seul.tsp;  
  2. /* 
  3.  * 蚂蚁类 
  4.  * 使用对象的复制,必须实现Cloneable接口,然后重写Object中clone()方法 
  5.  */  
  6. public class Ant implements Cloneable  
  7. {  
  8.     public int[] m_nPath=new int[PublicFun.N_CITY_COUNT];//蚂蚁走过的路径  
  9.     public double m_dbPathLength;//蚂蚁走过的路径长度  
  10.       
  11.     public int[] m_nAllowedCity=new int[PublicFun.N_CITY_COUNT];//蚂蚁没有去过的城市  
  12.     public int m_nCurCityNo;//当前所在城市的编号  
  13.     public int m_nMovedCityCount;//已经去过的城市数量  
  14.       
  15.       
  16.       
  17.     /* 
  18.      * 初始化函数,蚂蚁搜索前调用该方法 
  19.      */  
  20.     public void Init()  
  21.     {  
  22.         for (int i = 0; i < PublicFun.N_CITY_COUNT; i++)  
  23.         {  
  24.             m_nAllowedCity[i]=1;//设置全部城市没有去过  
  25.             m_nPath[i]=0;//蚂蚁走过的路径全部设置为0  
  26.         }  
  27.         m_dbPathLength=0.0; //蚂蚁走过的路径长度设置为0  
  28.           
  29.         m_nCurCityNo=PublicFun.rnd(0,PublicFun.N_CITY_COUNT);//随机选择一个出发城市  
  30.           
  31.         m_nPath[0]=m_nCurCityNo;//把出发城市保存的路径数组中  
  32.           
  33.         m_nAllowedCity[m_nCurCityNo]=0;//标识出发城市已经去过了  
  34.           
  35.         m_nMovedCityCount=1;//已经去过的城市设置为1;  
  36.     }  
  37.       
  38.     /* 
  39.      * 覆盖Object中的clone()方法 
  40.      * 实现对象的复制 
  41.      */  
  42.     protected Object clone() throws CloneNotSupportedException  
  43.     {  
  44.         return super.clone();  
  45.     }  
  46.     /* 
  47.      * 选择下一个城市 
  48.      * 返回值为城市编号 
  49.      */   
  50.     public int ChooseNextCity()  
  51.     {  
  52.           
  53.         int nSelectedCity=-1;//返回结果,初始化为-1  
  54.           
  55.         //计算当前城市和没去过城市的信息素的总和  
  56.         double dbTotal=0.0;  
  57.         double[] prob=new double[PublicFun.N_CITY_COUNT];//用来保存各个城市被选中的概率  
  58.           
  59.         for (int i = 0; i < PublicFun.N_CITY_COUNT; i++)  
  60.         {  
  61.             if(m_nAllowedCity[i]==1)//城市没去过  
  62.             {  
  63.                 //该城市和当前城市的信息素  
  64.                 prob[i]=Math.pow(PublicFun.g_Trial[m_nCurCityNo][i], PublicFun.ALPHA)*Math.pow(1.0/PublicFun.g_Distance[m_nCurCityNo][i],PublicFun.BETA);  
  65.                 dbTotal=dbTotal+prob[i];//累加信息素  
  66.             }  
  67.             else//如果城市去过了 则被选中的概率为0;  
  68.             {  
  69.                 prob[i]=0.0;  
  70.             }  
  71.               
  72.         }  
  73.           
  74.         //进行轮盘选择  
  75.           
  76.         double dbTemp=0.0;  
  77.         if(dbTotal>0.0)//如果总的信息素大于0  
  78.         {  
  79.             dbTemp=PublicFun.rnd(0.0, dbTotal);//取一个随机数  
  80.               
  81.             for (int i = 0; i < PublicFun.N_CITY_COUNT; i++)  
  82.             {  
  83.                 if(m_nAllowedCity[i]==1)//城市没有去过  
  84.                 {  
  85.                     dbTemp=dbTemp-prob[i];//相当于轮盘  
  86.                       
  87.                     if(dbTemp<0.0)//轮盘停止转动,记下城市编号,跳出循环  
  88.                     {  
  89.                         nSelectedCity=i;  
  90.                         break;  
  91.                     }  
  92.                 }  
  93.                   
  94.             }  
  95.         }  
  96.           
  97.         /* 
  98.          * 如果城市间的信息素非常小 ( 小到比double能够表示的最小的数字还要小 )   
  99.          * 那么由于浮点运算的误差原因，上面计算的概率总和可能为0   
  100.          * 会出现经过上述操作，没有城市被选择出来   
  101.          * 出现这种情况，就把第一个没去过的城市作为返回结果   
  102.          */  
  103.         if(nSelectedCity==-1)  
  104.         {  
  105.             for (int i = 0; i < PublicFun.N_CITY_COUNT; i++)  
  106.             {  
  107.                 if(m_nAllowedCity[i]==1)//城市没有去过  
  108.                 {  
  109.                         nSelectedCity=i;  
  110.                         break;  
  111.                 }  
  112.             }  
  113.         }  
  114.         return nSelectedCity;  
  115.     }  
  116.       
  117.     /* 
  118.      * 蚂蚁在城市间移动 
  119.      */  
  120.     public void Move()  
  121.     {  
  122.         int nCityNo=ChooseNextCity();//选择下一个城市  
  123.         m_nPath[m_nMovedCityCount]=nCityNo;//保存蚂蚁走过的路径  
  124.         m_nAllowedCity[nCityNo]=0;//把这个城市设置为已经去过了  
  125.         m_nCurCityNo=nCityNo;//改变当前城市为选择的城市  
  126.         m_nMovedCityCount++;//已经去过的城市加1  
  127.     }  
  128.       
  129.     /* 
  130.      * 蚂蚁进行一次搜索 
  131.      */  
  132.     public void Search()  
  133.     {  
  134.         Init();//蚂蚁搜索前,进行初始化  
  135.           
  136.         //如果蚂蚁去过的城市数量小于城市数量,就继续移动  
  137.         while (m_nMovedCityCount<PublicFun.N_CITY_COUNT)  
  138.         {  
  139.             Move();//移动  
  140.         }  
  141.         //完成搜索后计算走过的路径长度  
  142.         CalPathLength();  
  143.     }  
  144.       
  145.     /* 
  146.      * 计算蚂蚁走过的路径长度 
  147.      */  
  148.     public void CalPathLength()  
  149.     {  
  150.         m_dbPathLength=0.0;//先把路径长度置0  
  151.         int m=0;  
  152.         int n=0;  
  153.           
  154.         for(int i=1;i<PublicFun.N_CITY_COUNT;i++)  
  155.         {  
  156.             m=m_nPath[i];  
  157.             n=m_nPath[i-1];  
  158.             m_dbPathLength=m_dbPathLength+PublicFun.g_Distance[m][n];  
  159.         }  
  160.         //加上从最后城市返回出发城市的距离  
  161.         n=m_nPath[0];  
  162.         m_dbPathLength=m_dbPathLength+PublicFun.g_Distance[m][n];  
  163.         m_dbPathLength=(Math.round(m_dbPathLength*100))/100.0;  
  164.     }  
  165. }  

TSP问题类

[java]  view plain  copy
  1. package com.seul.tsp;  
  2. /* 
  3.  * Tsp问题类 
  4.  */  
  5. public class Tsp  
  6. {  
  7.     //蚂蚁数组  
  8.     public Ant[] m_antAry=new Ant[PublicFun.N_ANT_COUNT];  
  9.     public Ant[] m_betterAnts=new Ant[PublicFun.N_IT_COUNT];//定义一组蚂蚁,用来保存每一次搜索中较优结果,不参与搜索  
  10.     public Ant m_bestAnt;//定义一个蚂蚁变量,用来保存最终最优结果,不参与搜索  
  11.       
  12.     /* 
  13.      * 初始化数据 
  14.      */  
  15.     public void InitData() throws CloneNotSupportedException  
  16.     {  
  17.         //初始化所有蚂蚁  
  18.           
  19.         PublicFun.g_Distance=new double[PublicFun.N_CITY_COUNT][PublicFun.N_CITY_COUNT];  
  20.         PublicFun.g_Trial=new double[PublicFun.N_CITY_COUNT][PublicFun.N_CITY_COUNT];  
  21.         m_bestAnt=new Ant();  
  22.         for (int i = 0; i <PublicFun.N_ANT_COUNT; i++)  
  23.         {  
  24.             m_antAry[i]=new Ant();  
  25.         }  
  26.         for (int i = 0; i < PublicFun.N_IT_COUNT; i++)  
  27.         {  
  28.             m_betterAnts[i]=new Ant();  
  29.             m_betterAnts[i].m_dbPathLength=PublicFun.DB_MAX;//把较优蚂蚁的路径长度设置为一个很大值  
  30.         }  
  31.           
  32.         //先把最优蚂蚁的路径长度设置为一个很大值  
  33.         m_bestAnt.m_dbPathLength=PublicFun.DB_MAX;  
  34.           
  35.         //随机生成两城市之间的距离  
  36.         for(int i=0;i<PublicFun.N_CITY_COUNT;i++)  
  37.         {  
  38.             for(int j=i;j<PublicFun.N_CITY_COUNT;j++)  
  39.             {  
  40.                 if(i==j)  
  41.                     PublicFun.g_Distance[i][j]=0.0;//同一个城市为0  
  42.                 else  
  43.                 {  
  44.                     PublicFun.g_Distance[i][j]=PublicFun.rnd(20.0,100.0);//i-j的距离与j-i的距离相等  
  45.                     PublicFun.g_Distance[j][i]=PublicFun.g_Distance[i][j];  
  46.                 }  
  47.             }  
  48.         }  
  49.         //初始化信息素  
  50.         for(int i=0;i<PublicFun.N_CITY_COUNT;i++)  
  51.         {  
  52.             for(int j=0;j<PublicFun.N_CITY_COUNT;j++)  
  53.             {  
  54.                 PublicFun.g_Trial[i][j]=1.0;  
  55.             }  
  56.         }  
  57.           
  58.         Iterator();//开始迭代  
  59.           
  60.     }  
  61.       
  62.     /* 
  63.      * 更新环境信息素 
  64.      */  
  65.       
  66.     public void UpdateTrial()  
  67.     {  
  68.         //临时数组,保存各只蚂蚁在两两城市间新留下的信息素  
  69.         double[][] dbTempAry=new double[PublicFun.N_CITY_COUNT][PublicFun.N_CITY_COUNT];  
  70.           
  71.         //全部设置为0;  
  72.         for (int i = 0; i <PublicFun.N_CITY_COUNT; i++)  
  73.         {  
  74.             for (int j = 0; j < PublicFun.N_CITY_COUNT; j++)  
  75.             {  
  76.                 dbTempAry[i][j]=0.0;  
  77.             }  
  78.         }  
  79.         //计算新增加的信息素,保存到临时变量  
  80.         int m=0;  
  81.         int n=0;  
  82.         for(int i=0; i<PublicFun.N_ANT_COUNT;i++)  
  83.         {  
  84.             for (int j = 1; j < PublicFun.N_CITY_COUNT; j++)  
  85.             {  
  86.                 m=m_antAry[i].m_nPath[j];  
  87.                 n=m_antAry[i].m_nPath[j-1];  
  88.                 dbTempAry[n][m]=dbTempAry[n][m]+PublicFun.DBQ/m_antAry[i].m_dbPathLength;  
  89.                 dbTempAry[m][n]=dbTempAry[n][m];  
  90.             }  
  91.               
  92.             //最后城市与开始城市之间的信息素  
  93.             n=m_antAry[i].m_nPath[0];  
  94.             dbTempAry[n][m]=dbTempAry[n][m]+PublicFun.DBQ/m_antAry[i].m_dbPathLength;  
  95.             dbTempAry[m][n]=dbTempAry[n][m];  
  96.         }  
  97.           
  98.         //更新环境信息素  
  99.         for (int i = 0; i < PublicFun.N_CITY_COUNT; i++)  
  100.         {  
  101.             for (int j = 0; j < PublicFun.N_CITY_COUNT; j++)  
  102.             {  
  103.                 //最新的环境信息素 = 留存的信息素 + 新留下的信息素    
  104.                 PublicFun.g_Trial[i][j]=PublicFun.g_Trial[i][j]*PublicFun.ROU+dbTempAry[i][j];  
  105.             }  
  106.         }  
  107.     }  
  108.       
  109.       
  110.     /* 
  111.      * 迭代 
  112.      */  
  113.     public void Iterator() throws CloneNotSupportedException  
  114.     {  
  115.         //迭代次数内进行循环  
  116.   
  117.         for (int i = 0; i < PublicFun.N_IT_COUNT; i++)  
  118.         {  
  119.             //每只蚂蚁搜索一遍  
  120.             for(int j=0;j<PublicFun.N_ANT_COUNT;j++)  
  121.             {  
  122.                 m_antAry[j].Search();  
  123.             }  
  124.               
  125.             //保存较优结果  
  126.             for(int j=0;j<PublicFun.N_ANT_COUNT;j++)  
  127.             {  
  128.                 if (m_antAry[j].m_dbPathLength < m_betterAnts[i].m_dbPathLength)  
  129.                 {  
  130.                     m_betterAnts[i] = (Ant) m_antAry[j].clone();  
  131.                 }  
  132.             }  
  133.             UpdateTrial();  
  134.         }  
  135.   
  136.         //找出最优蚂蚁  
  137.         for(int k=0;k<PublicFun.N_IT_COUNT;k++)  
  138.         {  
  139.             if(m_betterAnts[k].m_dbPathLength<m_bestAnt.m_dbPathLength)  
  140.             {  
  141.                 m_bestAnt=m_betterAnts[k];  
  142.             }  
  143.         }  
  144.           
  145.     //  getBetterAnt();//输出每次的较优路径  
  146. //      getBestAnt();//输出最佳路径  
  147.           
  148.     }  
  149.     /* 
  150.      * 输出最佳路径到控制台.(暂不使用,但保留) 
  151.      */  
  152.     public void getBestAnt()  
  153.     {  
  154.         System.out.println("最佳路径:");  
  155.         System.out.println( "路径:"+getAntPath(m_bestAnt)+"长度:"+getAntLength(m_bestAnt));  
  156.     }  
  157.       
  158.     /* 
  159.      * 输出每次的较优路径到控制台.(暂不使用,但保留) 
  160.      */  
  161.     public void getBetterAnt()  
  162.     {  
  163.         System.out.println("每一次的较优路径:");  
  164.         for (int i = 0; i < m_betterAnts.length; i++)  
  165.         {  
  166.              System.out.println("("+i+") 路径:"+getAntPath(m_betterAnts[i])+"长度:"+getAntLength(m_betterAnts[i]));  
  167.         }  
  168.     }  
  169.   
  170.     /* 
  171.      * 返回蚂蚁经过的路径 
  172.      */  
  173.     public String getAntPath(Ant ant)  
  174.     {  
  175.         String s="";  
  176.         for(int i=0;i<ant.m_nPath.length;i++)  
  177.         {  
  178.             s+=ant.m_nPath[i]+"-";  
  179.         }  
  180.         s+=ant.m_nPath[0];  //蚂蚁最后要回到开始城市  
  181.         return s;  
  182.     }  
  183.     /* 
  184.      * 返回蚂蚁经过的长度 
  185.      */  
  186.     public double getAntLength(Ant ant)  
  187.     {  
  188.         return ant.m_dbPathLength;  
  189.     }  
  190.       
  191.       
  192. }  

界面初始化

[java]  view plain  copy
  1. package com.seul.tsp;  
  2.   
  3. import java.awt.Color;  
  4. import java.awt.Font;  
  5. import java.awt.event.ActionEvent;  
  6. import java.awt.event.ActionListener;  
  7.   
  8. import javax.swing.JButton;  
  9. import javax.swing.JFrame;  
  10. import javax.swing.JLabel;  
  11. import javax.swing.JScrollPane;  
  12. import javax.swing.JTextArea;  
  13. import javax.swing.JTextField;  
  14. import javax.swing.SwingConstants;  
  15. /* 
  16.  * 界面实现 
  17.  */  
  18. @SuppressWarnings("serial")  
  19. public class Frame extends JFrame  
  20. {  
  21.     JLabel headLabel;  
  22.     JLabel antLabel;  
  23.     JLabel itLabel;  
  24.     JLabel cityLabel;  
  25.     JLabel betterAntLabel;  
  26.     JLabel bestAntLabel;  
  27.     JTextField antTF;  
  28.     JTextField itTF;  
  29.     JTextField cityTF;  
  30.     JTextArea betterAntTA;  
  31.     JTextArea bestAntTA;  
  32.     JButton beginBtn;  
  33.     JScrollPane betterAntScroll;  
  34.     JScrollPane bestAntScroll;  
  35.       
  36.     JLabel descLabel;  
  37.     public Frame()  
  38.     {  
  39.         Init();  
  40.     }  
  41.     /* 
  42.      * 界面初始化函数 
  43.      */  
  44.     private void Init()  
  45.     {  
  46.         String descStr = "<html><font color=green>说明:<br/>本测试程序两两城市间距离为随机生成20.0~100.0之间的随机浮点数<font/><br/><br/><br/><br/><font color=black>&copy;2016 Seul</font></html>";  
  47.         headLabel=new JLabel("蚁群算法解决TSP问题演示");  
  48.         antLabel=new JLabel("请输入蚂蚁数量:");  
  49.         itLabel=new JLabel("请输入迭代次数:");       
  50.         cityLabel=new JLabel("请输入城市数量:");  
  51.         betterAntLabel=new JLabel("每一次迭代的较优路径以及长度");  
  52.         bestAntLabel=new JLabel("最佳路径以及长度");  
  53.         antTF=new JTextField("50");  
  54.         itTF=new JTextField("200");  
  55.         cityTF=new JTextField("15");  
  56.         betterAntTA = new JTextArea();  
  57.         bestAntTA=new JTextArea();  
  58.         beginBtn=new JButton("开始运行");  
  59.         betterAntScroll=new JScrollPane(betterAntTA);  
  60.         bestAntScroll=new JScrollPane(bestAntTA);  
  61.           
  62.         descLabel=new JLabel(descStr);  
  63.         descLabel.setBounds(20,220,150,150);  
  64.           
  65.         setBounds(300, 150, 600, 400);  
  66.         setTitle("蚁群算法解决TSP问题演示程序");  
  67.         setLayout(null);  
  68.         setResizable(false);  
  69.           
  70.         headLabel.setBounds(0, 0, 600, 50);  
  71.         headLabel.setHorizontalAlignment(SwingConstants.CENTER);  
  72.         headLabel.setFont(new Font("隶书", Font.BOLD, 20));  
  73.           
  74.         antLabel.setBounds(20, 60, 100, 20);  
  75.         cityLabel.setBounds(20, 100, 100, 20);  
  76.         itLabel.setBounds(20, 140, 100, 20);  
  77.           
  78.         antTF.setBounds(125, 60, 50, 20);  
  79.         cityTF.setBounds(125, 100, 50, 20);  
  80.         itTF.setBounds(125, 140, 50, 20);  
  81.           
  82.         beginBtn.setBounds(40, 180, 110, 25);  
  83.           
  84.         betterAntLabel.setBounds(200, 60, 200, 20);  
  85.         betterAntScroll.setBounds(200, 80, 380, 200);  
  86.           
  87.         bestAntLabel.setBounds(200, 300, 200, 20);  
  88.         bestAntLabel.setForeground(Color.red);  
  89.         bestAntScroll.setBounds(200, 320, 380, 40);  
  90.         bestAntTA.setBackground(Color.CYAN);  
  91.         bestAntTA.setFont(new Font("微软雅黑", Font.BOLD, 13));  
  92.           
  93.         getContentPane().add(headLabel);  
  94.         getContentPane().add(antLabel);  
  95.         getContentPane().add(antTF);  
  96.         getContentPane().add(itLabel);  
  97.         getContentPane().add(itTF);  
  98.         getContentPane().add(cityLabel);  
  99.         getContentPane().add(cityTF);  
  100.         getContentPane().add(beginBtn);  
  101.         getContentPane().add(betterAntLabel);  
  102.         getContentPane().add(betterAntScroll);  
  103.         getContentPane().add(bestAntLabel);  
  104.         getContentPane().add(bestAntScroll);  
  105.         getContentPane().add(descLabel);  
  106.           
  107.         setDefaultCloseOperation(EXIT_ON_CLOSE);  
  108.           
  109.         beginBtn.addActionListener(new ActionListener()  
  110.         {  
  111.             public void actionPerformed(ActionEvent e)  
  112.             {  
  113.                 try  
  114.                 {  
  115.                     Begin();  
  116.                 } catch (CloneNotSupportedException e1)  
  117.                 {  
  118.                     e1.printStackTrace();  
  119.                 }  
  120.             }  
  121.         });  
  122.         setVisible(true);  
  123.     }  
  124.       
  125.     /* 
  126.      * 开始运算 
  127.      */  
  128.     public void Begin() throws CloneNotSupportedException  
  129.     {  
  130.         betterAntTA.setText("");  
  131.         bestAntTA.setText("");  
  132.         String antCountStr=antTF.getText().replaceAll("[^\\d]", "");//去除所有非数字字符  
  133.         String itCountStr=itTF.getText().replaceAll("[^\\d]", "");  
  134.         String cityCountStr=cityTF.getText().replaceAll("[^\\d]", "");  
  135.           
  136.         if(!antCountStr.equals("")&&!itCountStr.equals("")&&!cityCountStr.equals(""))//不为"";  
  137.         {  
  138.             PublicFun.N_ANT_COUNT=Integer.parseInt(antCountStr);// 转换为数字  
  139.             PublicFun.N_IT_COUNT=Integer.parseInt(itCountStr);  
  140.             PublicFun.N_CITY_COUNT=Integer.parseInt(cityCountStr);  
  141.         }  
  142.           
  143.         /* 
  144.          * 实例化Tsp  
  145.          */  
  146.           
  147.         Tsp tsp=new Tsp();    
  148.         tsp.InitData();//开始执行  
  149.           
  150.         /* 
  151.          * 把结果显示在窗口中 
  152.          */  
  153.         for (int i = 0; i < tsp.m_betterAnts.length; i++)  
  154.         {  
  155.              betterAntTA.append("("+(i+1)+") 路径:"+tsp.getAntPath(tsp.m_betterAnts[i])+"长度:"+tsp.getAntLength(tsp.m_betterAnts[i])+"\n");  
  156.         }  
  157.         betterAntTA.setCaretPosition(0);  
  158.         bestAntTA.append("路径:"+tsp.getAntPath(tsp.m_bestAnt)+"长度:"+tsp.getAntLength(tsp.m_bestAnt));  
  159.         bestAntTA.setCaretPosition(0);  
  160.   
  161.   
  162.     }  
  163. }  

入口

[java]  view plain  copy
  1. package com.seul.tsp;  
  2.   
  3. /* 
  4.  * 入口类 
  5.  */  
  6. public class Main  
  7. {  
  8.     public static void main(String[] args) throws CloneNotSupportedException  
  9.     {  
  10.         new Frame();  
  11.     }  
  12. }  
蚁群算法java实现_简单蚁群算法 + JAVA实现蚁群算法
weixin_42685438的博客
02-12 1453
一 引言蚁群算法(ant colonyoptimization，ACO)，又称蚂蚁算法，是一种用来在图中寻找优化路径的机率型技术。它由MarcoDorigo于1992年在他的博士论文中引入，其灵感来源于蚂蚁在寻找食物过程中发现路径的行为。蚁群算法是一种模拟进化算法。初步的研究表明该算法具有许多优良的性质。针对PID控制器参数优化设计问题，将蚁群算法设计的结果与遗传算法设计的结果进行了比较，数值仿真...
java实现旅行商问题_动态规划法解旅行商问题（TSP）问题的java实现
weixin_42236063的博客
02-16 821
import java.util.ArrayList;import java.util.List;import java.util.Map;import java.util.HashMap;public class TSP {private double[][] dArray; //距离矩阵private int length; //距离矩阵的长度private int lengthOfLengt...
人工智能 蚁群算法 旅行商问题 java 报告+代码+详细注释
03-29
包括了图形用户界面的 蚁群算法解决旅行商问题 语言：java 内容：附录中包括了完整代码和详细注释； 运行测试情况； 详细阐述了各段代码的输入输出数据的格式要求； 各个类的定义和功能的说明
基于禁忌搜索的TSP问题建模求解（Java）
博客简介
03-18 478
邻域移动：邻域移动是从一个解产生另一个解的途径。本文采用2-opt。禁忌表：通常记录前若干次的移动，禁止这些移动在近期内返回。在迭代固定次数后，禁忌表释放这些移动，重新参加运算。选择策略：即择优规则，是对当前的邻域移动选择而采用的准则。当前采用最广泛的两类策略是最好解优先策略和第一个改进解优先策略。本文采用最好解优先特赦准则：考虑邻域内所有解（包括禁忌解），并逐一进行评估，发现出色的禁忌解，将其解禁。终止规则：迭代次数控制。
TSP-旅行商问题(基于动态规划或蚁群算法求解)
最新发布
qq_20604231的博客
09-18 2149
本文首先介绍了旅行商问题的定义，然后介绍了针对小规模的问题的动态规划求解方法，针对较大规模问题的蚁群算法，并提供了两者的Python实现。
基于Java的蚂蚁算法实现---求解TSP(旅行商问题)
10-16
蚂蚁算法求解TSP旅行商问题，有详细的源代码及注释,采用面向对象设计思路
动态规划法解旅行商问题（TSP）问题的java实现
05-08
动态规划法解旅行商问题（TSP）问题的java实现
蚁群算法-TSP
From2016cxg
02-15 1044
%% 第22章 蚁群算法的优化计算——旅行商问题(TSP)优化 % <html> % <table border="0" width="600px" id="table1"> <tr> <td><b><font size="2">该案例作者申明：</font></b></td> </tr> <tr><td><span class="comment"><font size="2"
tsp java_蚁群算法java实现以及TSP问题蚁群算法求解
weixin_39951419的博客
02-12 252
1. 蚁群算法简介蚁群算法(Ant Clony Optimization， ACO)是一种群智能算法，它是由一群无智能或有轻微智能的个体(Agent)通过相互协作而表现出智能行为，从而为求解复杂问题提供了一个新的可能性。蚁群算法最早是由意大利学者Colorni A., Dorigo M. 等于1991年提出。经过20多年的发展，蚁群算法在理论以及应用研究上已经得到巨大的进步。蚁群算法是一种仿生学算...
java实现蚁群算法解决旅行商问题TSP问题.zip
12-31
java实现蚁群算法解决旅行商问题TSP问题.zipjava实现蚁群算法解决旅行商问题TSP问题.zipjava实现蚁群算法解决旅行商问题TSP问题.zipjava实现蚁群算法解决旅行商问题TSP问题.zipjava实现蚁群算法解决旅行商问题TSP...
蚁群算法java实现_蚁群算法java实现以及TSP问题蚁群算法求解
weixin_26997697的博客
02-12 795
1. 蚁群算法简介蚁群算法(Ant Clony Optimization， ACO)是一种群智能算法，它是由一群无智能或有轻微智能的个体(Agent)通过相互协作而表现出智能行为，从而为求解复杂问题提供了一个新的可能性。蚁群算法最早是由意大利学者Colorni A., Dorigo M. 等于1991年提出。经过20多年的发展，蚁群算法在理论以及应用研究上已经得到巨大的进步。蚁群算法是一种仿生学算...
旅行商问题（TSP问题）
10-16
# -TSP- 本文主要是用以下方法解决旅行商问题（TSP问题） 详情见：https://blog.csdn.net/weixin_42715356/article/details/83089108 穷举策略 自顶向下的算法：深度优先搜索算法->回溯法 ：广度优先搜索算法->分支限界算法 自底向上的算法：动态规划 启发式策略 贪心算法、蚁群算法
用蚁群算法解决TSP问题
06-20
【标题】"用蚁群算法解决TSP问题"涉及到的是计算几何与优化领域的一个经典问题——旅行商问题（Travelling Salesman Problem, TSP），以及一种启发式搜索方法——蚁群算法（Ant Colony Optimization, ACO）。...
ACOforTSP.zip_ANT COLONY tsp JAVA_蚁群_蚁群权重_蚁群算法 java
09-20
《蚁群算法在解决旅行商问题中的应用——Java实现》 旅行商问题（Traveling Salesman Problem, TSP）是图论中一个经典的组合优化问题，它的目标是找到访问每座城市一次并返回起点的最短路径。这个问题的复杂度随着...
蚁群算法matlab完整代码-Travelling-Salesman-Problem:旅行商问题
05-24
蚁群算法matlab完整代码旅行商问题 附带的代码使用Java和Matlab编程语言。 它实现了蚁群优化算法来解决旅行商问题（TSP），这是一个NP完全问题。 为了评估蚁群优化算法的性能，在几个研究工作之间进行了比较研究，...
旅行商问题
youyouxiong的博客
04-23 356
3. **动态规划**：将问题分解为更小的子问题，逐步构建最优解。1. **暴力搜索**：尝试所有可能的路径，然后选择最短的一条。2. **贪心算法**：选择最短的边进行连接，直到所有城市都被访问一次。- **最近邻算法**：从任意城市开始，每次选择最近的未访问城市作为下一个目的地。- **模拟退火**：模拟物理退火过程，逐步找到问题的近似最优解。- **遗传算法**：模拟自然选择过程，通过迭代优化路径。- **复杂性**：计算复杂性高，难以找到高效算法。- **简单描述**：简单直观，容易理解。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值