TSP问题的解法（java版）

最新推荐文章于 2024-07-15 18:28:03 发布
最新推荐文章于 2024-07-15 18:28:03 发布
阅读量6.6k 收藏 4
点赞数 2
文章标签： java distance calendar random string import


import java.util.*;

import javax.swing.JOptionPane;

public class Tsp { 
 private int cityNum ;    //城市个数
 private int popSize = 50;    //种群数量
 private int maxgens = 10000;   //迭代次数
 private double pxover = 0.8;   //交叉概率
 private double pmultation = 0.05;  //变异概率
 private long[][] distance = new long[100][100];//城市的数量最好不要超过100个
 private int range = 2000;    //用于判断何时停止的数组区间
 
 private class genotype {
  int city[] = new int[cityNum];  //单个基因的城市序列
  long fitness;      //该基因的适应度
  double selectP;      //选择概率
  double exceptp;      //期望概率
  int isSelected;      //是否被选择
 }
 private genotype[] citys = new genotype[popSize];

 /**
  *  构造函数，初始化种群
  */
 public Tsp() {
  
  String s = JOptionPane.showInputDialog("请输入城市的个数：");     //由于最后要回到原来的城市，输入城市时最好多算一个
  cityNum = Integer.parseInt(s);
  
  for (int i = 0; i < popSize; i++) {
   citys[i] = new genotype();
   int[] num = new int[cityNum];
   for (int j = 0; j < cityNum; j++)
    num[j] = j;
   int temp = cityNum;
   for (int j = 0; j < cityNum; j++) {
    int r = (int) (Math.random() * temp);
    citys[i].city[j] = num[r];
    num[r] = num[temp - 1];
    temp--;
   }
   citys[i].fitness = 0;
   citys[i].selectP = 0;
   citys[i].exceptp = 0;
   citys[i].isSelected = 0;
  }
  initDistance();
 }
 
 /**
  *  计算每个种群每个基因个体的适应度，选择概率，期望概率，和是否被选择。
  */
 public void CalAll(){
  for( int i = 0; i< popSize; i++){
   citys[i].fitness = 0;
   citys[i].selectP = 0;
   citys[i].exceptp = 0;
   citys[i].isSelected = 0;
  }
  CalFitness();
  CalSelectP();
  CalExceptP();
  CalIsSelected();
 }

 /**
  *  填充，将多选的填充到未选的个体当中
  */
 public void pad(){
  int best = 0;
  int bad = 0;
  while(true){   
   while(citys[best].isSelected <= 1 && best<popSize-1)
    best ++;
   while(citys[bad].isSelected != 0 && bad<popSize-1)
    bad ++;
   for(int i = 0; i< cityNum; i++)
    citys[bad].city[i] = citys[best].city[i];
    citys[best].isSelected --;
    citys[bad].isSelected ++;
    bad ++; 
   if(best == popSize ||bad == popSize)
    break;
  }
 }
 
 /**
  *  交叉主体函数
  */
 public void crossover() {
  int x;
  int y;
  int pop = (int)(popSize* pxover /2);
  while(pop>0){
   x = (int)(Math.random()*popSize);
   y = (int)(Math.random()*popSize);
   
   executeCrossover(x,y);//x y 两个体执行交叉
   pop--;
  }
 }
 
 /**
  * 执行交叉函数
  * @param 个体x
  * @param 个体y
  * 对个体x和个体y执行佳点集的交叉，从而产生下一代城市序列
  */
 private void executeCrossover(int x,int y){
  int dimension = 0;
  for( int i = 0 ;i < cityNum; i++)
   if(citys[x].city[i] != citys[y].city[i]){
    dimension ++;
   } 
  int diffItem = 0;
  double[] diff = new double[dimension];

  for( int i = 0 ;i < cityNum; i++){
   if(citys[x].city[i] != citys[y].city[i]){
    diff[diffItem] = citys[x].city[i];
    citys[x].city[i] = -1;
    citys[y].city[i] = -1;
    diffItem ++;
   } 
  }
 
  Arrays.sort(diff);

  double[] temp = new double[dimension];
  temp = gp(x, dimension);

  for( int k = 0; k< dimension;k++)
   for( int j = 0; j< dimension; j++)
    if(temp[j] == k){
     double item = temp[k];
     temp[k] = temp[j];
     temp[j] = item;
     
     item = diff[k];
     diff[k] = diff[j];
     diff[j] = item; 
    }
  int tempDimension = dimension;
  int tempi = 0;

  while(tempDimension> 0 ){
   if(citys[x].city[tempi] == -1){
    citys[x].city[tempi] = (int)diff[dimension - tempDimension];
    
    tempDimension --;
   } 
   tempi ++;
  }

  Arrays.sort(diff);

  temp = gp(y, dimension);

  for( int k = 0; k< dimension;k++)
   for( int j = 0; j< dimension; j++)
    if(temp[j] == k){
     double item = temp[k];
     temp[k] = temp[j];
     temp[j] = item;
     
     item = diff[k];
     diff[k] = diff[j];
     diff[j] = item; 
    }

  tempDimension = dimension;
  tempi = 0;

  while(tempDimension> 0 ){
   if(citys[y].city[tempi] == -1){
    citys[y].city[tempi] = (int)diff[dimension - tempDimension];
    
    tempDimension --;
   } 
   tempi ++;
  }

 }
 
 /**
  * @param individual 个体
  * @param dimension   维数
  * @return 佳点集 (用于交叉函数的交叉点） 在executeCrossover()函数中使用
  */
 private double[] gp(int individual, int dimension){
  double[] temp = new double[dimension];
  double[] temp1 = new double[dimension];
  int p = 2 * dimension + 3;

  while(!isSushu(p))
   p++;

  for( int i = 0; i< dimension; i++){
   temp[i] = 2*Math.cos(2*Math.PI*(i+1)/p) * (individual+1);
   temp[i] = temp[i] - (int)temp[i];
   if( temp [i]< 0)
    temp[i] = 1+temp[i];

  }
  for( int i = 0; i< dimension; i++)
   temp1[i] = temp[i];
  Arrays.sort(temp1); 
  //排序
  for( int i = 0; i< dimension; i++)
   for( int j = 0; j< dimension; j++)
    if(temp[j]==temp1[i])
     temp[j] = i; 
  return temp;
 }
 
 
 /**
  *  变异
  */
 public void mutate(){
  double random;
  int temp;
  int temp1;
  int temp2;
  for( int i = 0 ; i< popSize; i++){
   random = Math.random();
   if(random<=pmultation){
    temp1 = (int)(Math.random() * (cityNum));
    temp2 = (int)(Math.random() * (cityNum));
    temp = citys[i].city[temp1];
    citys[i].city[temp1] = citys[i].city[temp2];
    citys[i].city[temp2] = temp;

   }
  }  
 }
 
 /**
  * 打印当前代数的所有城市序列，以及其相关的参数
  */
/* public void print(){
  for (int i = 0; i < popSize; i++) {
   System.out.print("第 "+ i+"个体：");
   for (int j = 0; j < cityNum; j++)
    System.out.print(citys[i].city[j] + "  ");
    System.out.println(" 适应度:" + citys[i].fitness + " 选择概率:"
     + citys[i].selectP +" 期望概率："+citys[i].exceptp+ " 是否被选择:" + citys[i].isSelected);
  }
  
  for (int i = 0; i < cityNum; i++) {
   for (int j = 0; j < cityNum; j++){
    System.out.print(distance[i][j]+" ");
   }
   System.out.println();
  }
 }*/

 
// private
 /**
  * 初始化各城市之间的距离
  */
 private void initDistance(){
  for(int i = 0; i < cityNum; i++ ) {       //为了输入的更快当 i = j 时自动的赋值为0     
   distance[i][i] = 0;
  }
  for (int i = 0; i < cityNum ; i++) {           //由于二维数组的存储是对称的可以用压缩存储的方法初始化
   for (int j = i + 1; j < cityNum; j++){
     String s1 = JOptionPane.showInputDialog("请输入第"+ i +"城市到第"+ j +"城市之间的距离");
     distance[i][j] = Integer.parseInt(s1);
     distance[j][i] = distance[i][j];
    
   }
  }
 }
 
 /**
  * 计算所有城市序列的适应度
  */
 private void CalFitness() {
  for (int i = 0; i < popSize; i++) {
   for (int j = 0; j < cityNum - 1; j++)
    citys[i].fitness += distance[citys[i].city[j]][citys[i].city[j + 1]];
   citys[i].fitness += distance[citys[i].city[0]][citys[i].city[cityNum - 1]];
  }
 }
 
 /**
  * 计算选择概率
  */
 private void CalSelectP(){
  long sum = 0;
  for( int i = 0; i< popSize; i++)
   sum += citys[i].fitness;
  for( int i = 0; i< popSize; i++)
   citys[i].selectP = (double)citys[i].fitness/sum;

 }
 
 /**
  * 计算期望概率
  */
 private void CalExceptP(){
  for( int i = 0; i< popSize; i++)
   citys[i].exceptp = (double)citys[i].selectP * popSize;
 }
 
 /**
  * 计算该城市序列是否较优，较优则被选择，进入下一代
  */
 private void CalIsSelected(){
  int needSelecte = popSize;
  for( int i = 0; i< popSize; i++)
   if( citys[i].exceptp<1){
    citys[i].isSelected++;
    needSelecte --;
   }
  double[] temp = new double[popSize];
  for (int i = 0; i < popSize; i++) {
   temp[i] = citys[i].exceptp*10;
  }
  int j = 0;
  while (needSelecte != 0) {
   for (int i = 0; i < popSize; i++) {
    if ((int) temp[i] == j) {
     citys[i].isSelected++;
     needSelecte--;
     if (needSelecte == 0)
      break;
    }
   }
   j++;
  }
  
 }
 
 /**
  * @param x
  * @return 判断一个数是否是素数的函数
  */
 private boolean isSushu( int x){
     if(x<2) return false;
     for(int i=2;i<=x/2;i++)
     if(x%i==0&&x!=2) return false;

     return true;
  }
 
 /**
  * @param x 数组
  * @return x数组的值是否全部相等，相等则表示x.length代的最优结果相同，则算法结束
  */
 private boolean isSame(long[] x){
  for( int i = 0; i< x.length -1; i++)
   if(x[i] !=x[i+1])
    return false;
  return true;
 }
 
 /**
  * 打印任意代最优的路径序列
  */
 private void printBestRoute(){
  CalAll();
  long temp = citys[0].fitness;
  int index = 0;
  for (int i = 1; i < popSize; i++) {
   if(citys[i].fitness<temp){
    temp = citys[i].fitness;
    index = i;
   }
  }
  System.out.println();
  System.out.println("最佳路径的序列：");
  for (int j = 0; j < cityNum; j++)
   System.out.print(citys[index].city[j] + "  ");
  System.out.println();
 }
 
 /**
  * 算法执行
  */
 public void run(){
  long[] result = new long[range];
  //result初始化为所有的数字都不相等
  for( int i  = 0; i< range; i++)
   result[i] = i;
  int index = 0;  //数组中的位置
  int num = 1;  //第num代
  while(maxgens>0){
   System.out.println("-----------------  第  "+num+" 代  -------------------------");
   CalAll();
   //print();
   pad();
   crossover();
   mutate();
   maxgens --;
   long temp = citys[0].fitness;
   for ( int i = 1; i< popSize; i++)
    if(citys[i].fitness<temp){
     temp = citys[i].fitness;
    }
   System.out.println("最优的解："+temp);
   result[index] = temp;
   if(isSame(result))
    break;
   index++;
   if(index==range)
    index = 0;
   num++;
  }
  printBestRoute();
 }
 
 /**
  * @param a 开始时间
  * @param b  结束时间
  */
 public void CalTime(Calendar a,Calendar b){
  long x = b.getTimeInMillis() - a.getTimeInMillis();
  long y = x/1000;
  x = x - 1000*y;
  System.out.println("算法执行时间："+y+"."+x+" 秒");
 }
 
 /**
  *    程序入口
  */
 public static void main(String[] args) {
  
  Calendar a = Calendar.getInstance(); //开始时间
  Tsp tsp = new Tsp();
  tsp.run();
  Calendar b = Calendar.getInstance(); //结束时间
  tsp.CalTime(a, b);
  
 }
}

Kevin涂腾飞
关注
tsp java_基于贪心算法求解TSP问题（JAVA）
weixin_34205814的博客
02-12 445
前段时间在搞贪心算法，为了举例，故拿TSP来开刀，写了段求解算法代码以便有需之人，注意代码考虑可读性从最容易理解角度写，没有优化，有需要可以自行优化！一、TPS问题TSP问题(Travelling Salesman Problem)即旅行商问题，又译为旅行推销员问题、货郎担问题，是数学领域中著名问题之一。假设有一个旅行商人要拜访n个城市，他必须选择所要走的路径，路径的限制是每个城市只能拜访一次，而...
java tsp问题_蚁群算法（Java）tsp问题
weixin_33143629的博客
02-12 462
1、理论概述1.1、TSP问题旅行商问题，即TSP问题(旅行推销员问题、货郎担问题)，是数学领域中著名问题之一。假设有一个旅行商人要拜访n个城市，他必须选择所要走的路径，路径的限制是每个城市只能拜访一次，而且最后要回到原来出发的城市。路径的选择目标是要求得的路径路程为所有路径之中的最小值。TSP问题是一个组合优化问题。该问题可以被证明具有NP计算复杂性，迄今为止，这类问题中没有一个找到有效解决算法...
动态规划法解旅行商问题（TSP）问题的java实现
05-08
动态规划法解旅行商问题（TSP）问题的java实现
解决【TSP旅行商】问题的【Java】编程的优化路径算法
最新发布
xixixixixixixi21的博客
07-15 192
请注意，这两种算法在实际应用中可能会有优化空间，例如通过并行计算、剪枝技术或更高效的近似算法。同时，TSP是一个NP完全问题，找到全局最优解的困难度随着城市数增加而指数级增长。因此，实际应用可能还需要结合其他方法，如局部搜索或混合策略。时间复杂度: 动态规划部分的时间复杂度是O(n^2 * log n)，其中n是城市数，因为需要对所有边排序。时间复杂度: 这种算法通常涉及到迭代过程，每轮迭代的时间复杂度可以视为O(n^2)，n代表城市数。需要用到的库: 对于动态规划，可以直接使用Java内置数据结构；
遗传算法求解TSP问题Java界面版源码
05-27
遗传算法求解TSP问题Java界面版源码，思路代码和 http://blog.csdn.net/wangqiuyun/article/details/12838903 这篇文章思路是一样的，追加了Java Graphics做路径展示。
TSP问题java输出代码
01-23
可以用来输出tsp结果，画出路径,得到具体的行走路线
非完全图的TSP问题java解法(拙劣)
User_manxxx的博客
03-13 971
import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.Scanner; public class ThirdTest { private WeightedGraph G; private Node head; private Node node; private int count = 0; private int s.
TSP的Java实现.rar.rar_ tsp java_TSP in Java_TSP ja_TSPLIB_java T
09-23
在Java中实现TSP，需要对算法有深入的理解，因为TSP是一个NP完全问题，对于大规模问题没有多项式时间的精确解法。因此，开发者通常会采用启发式算法或近似算法来寻找接近最优的解决方案。例如，遗传算法、模拟退火、...
Tsp.rar_TSP JAVA_tsp
09-21
标题 "Tsp.rar_TSP JAVA_tsp" 指向的是一个关于解决旅行商问题（Traveling Salesman Problem, TSP）的Java程序。旅行商问题是一个经典的组合优化问题，它的目标是找到一个最短的可能路径，使得旅行商可以访问每个...
java tsp 遗传算法_遗传算法解决TSP问题
weixin_42701915的博客
02-27 1033
1实验环境实验环境：CPU i5-2450M@2.50GHz，内存6G，windows7 64位操作系统实现语言：java (JDK1.8)实验数据：TSPLIB，TSP采样实例库中的att48数据源数据地址：http://comopt.ifi.uni-heidelberg.de/software/TSPLIB95/tsp/att48.tsp.gzTSPLIB是一个从各种来源和各种类型中产生的TS...
用java解决TSP问题
11-04
在Java中处理TSP问题，通常会使用到以下知识点： 1. **图论基础**：TSP问题可以用图来表示，每个城市是一个节点，每条边代表两个城市之间的距离。因此，熟悉图的基本概念，如顶点、边、邻接矩阵和邻接表等是必要的...
TSP问题求解
08-20
本资源是南京航空航天大学大学计算机专业《图论与代数》或《离散数学》必做的大作业，里面是tsp问题求解，采用最小临近法与最小生成树法进行模拟解决。本资源涵盖源代码以及完备的文档说明，可以直接下载使用。
遗传算法求解TSP问题（Java实现）
08-11
使用遗传算法（GA）求解旅行商问题（TSP），此TSP问题来自于tsplib(http://comopt.ifi.uni-heidelberg.de/software/TSPLIB95/)上的数据att48，这是一个对称TSP问题，城市规模为48，其最优值为10628，最优路径为：1 8 38 31 44 18 7 28 6 37 19 27 17 43 30 36 46 33 20 47 21 32 39 48 5 42 24 10 45 35 4 26 2 29 34 41 16 22 3 23 14 25 13 11 12 15 40 9。代码修改自http://blog.csdn.net/wangqiuyun/article/details/12838903
Java 动态规划求解TSP问题
07-10
该文档使用Java语言编写了一个通用的TSP问题的求解方法，不仅进行了代码求解，还根据实际例子进行了手动求解和介绍，适合旅行商入门，以及Java语言的学习，附带源码和伪代码，以及详细的解释。
tsp问题贪心算法求解
12-25
任意输入城市数目，然后输入各城市间距离，运行显示各条旅行路线 使用贪心算法，找出次优解
tsp for java
10-02
tsp java 模拟退火 算法, 采用java5范式，需要实现的方法：1获取领域2获取当前解评价
关于TSP问题的几种解决办法
热门推荐
qq_39322743的博客
03-26 2万+
一、实验内容：分别用动态规划、贪心及分支限界法实现对TSP问题（无向图）的求解，并至少用两个测试用例对所完成的代码进行正确性及效率关系上的验证。二、程序设计的基本思想、原理和算法描述：（包括程序的数据结构、函数组成、输入/输出设计、符号名说明等）1、  动态规划法(1)数据结构：①利用二进制来表示集合，则集合S可由一个十进制数x相对应，此x所对应的二进制数为y，如果y的第k位为1，则表示k存在集合...
人工智能 --- 遗传算法解决TSP问题（JAVA版）
weixin_53068616的博客
10-30 3549
TSP问题，又称旅行商问题、货郎问题。 问题描述：再给定的城市地图中，要求旅行商走遍所有的城市，且每一个城市只能去一次，求该旅行商能够走遍所有城市的最短路径。 使用遗传算法解决该问题，遗传算法指通过给定的初始种群，进行有限次的种族迭代，最后使种族中保留个体适应度都是最高的（即适应度高的个体能够再种族中进行繁殖，它们的基因不会被淘汰）,适应度高的个体就代表要求的最优解。 本文中个体以字符串形式表示，个体集合使用Map<String,Integer&g...
TSP问题解法比较：动态规划、分支界限与回溯算法详解
文章作者来自xxx学校，他们通过实现在几种算法上的代码实现，对比这些方法在TSP问题上的性能，以评估哪种方法更适合实际应用，或者在特定场景下哪种解法更为优越。值得注意的是，尽管存在精确算法的理论限制，对于...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值