精华内容
下载资源
问答
  • 动态规划算法解决TSP问题

    万次阅读 2018-06-20 00:05:02
    旅行商问题,即TSP问题(Traveling Salesman Problem)又译为旅行推销员问题、货郎担问题,是数学领域中著名问题之一。假设有一个旅行商人要拜访n个城市,他必须选择所要走的路径,路径的限制是每个城市只能拜访一次...

    旅行商问题,即TSP问题(Traveling Salesman Problem)又译为旅行推销员问题、货郎担问题,是数学领域中著名问题之一。假设有一个旅行商人要拜访n个城市,他必须选择所要走的路径,路径的限制是每个城市只能拜访一次,而且最后要回到原来出发的城市。路径的选择目标是要求得的路径路程为所有路径之中的最小值。

    环境:程序使用语言java,jdk版本1.8,程序中用到的jar包:poi-3.17

    jar包下载地址:https://www.apache.org/dyn/closer.lua/poi/release/bin/poi-bin-3.17-20170915.tar.gz


    程序中使用的数据:下载地址:https://download.csdn.net/download/qq_35685675/10487174


    项目导入:


    3.实验主要源代码

    City.java//城市类,结构体

    package TSP;

    publicclass city {

       privateintname;

       privatedoubleX;

       privatedoubleY;

       public city(intnamedoublexdoubley) {

          super();

          this.name = name-1;

          X = x;

          Y = y;

       }

       publicint getName() {

          returnname;

       }

       publicvoid setName(intname) {

          this.name = name;

       }

       publicdouble getX() {

          returnX;

       }

       publicvoid setX(doublex) {

          X = x;

       }

       publicdouble getY() {

          returnY;

       }

       publicvoid setY(doubley) {

          Y = y;

       }

       @Override

       public String toString() {

          return"city [name=" + name + ",X=" + X + ", Y=" + Y + "]";

       }

      

    }

     

    inputData.Java//导入数据类

    package TSP;

    import java.io.File;

    import java.io.FileInputStream;

    import java.io.FileNotFoundException;

    import java.io.IOException;

    import java.util.ArrayList;

    import java.util.List;

     

    import org.apache.poi.hssf.usermodel.HSSFRow;

    import org.apache.poi.hssf.usermodel.HSSFSheet;

    import org.apache.poi.hssf.usermodel.HSSFWorkbook;

     

    publicclass inputData {

       @SuppressWarnings("resource")

       publicstatic List<city> input_att48(File file){

          List<city> cityList = new ArrayList<city>();

          try {

              HSSFWorkbook wookbook = new HSSFWorkbook(new FileInputStream(file));

              HSSFSheet sheet = wookbook.getSheet("Sheet1");

              introws = sheet.getPhysicalNumberOfRows();

              for(inti=1; i<rowsi++){

                 HSSFRow row = sheet.getRow(i);

                 if(row!=null){

                    city cy = new city(irow.getCell(1).getNumericCellValue(), row.getCell(2).getNumericCellValue());

                    cityList.add(cy);

                 }

              }

             

          catch (FileNotFoundException e) {

              System.out.println("File not fount!");

          catch (IOException e) {

              System.out.println("IO exception!");

          }

          returncityList;

       }

    }

     

    DP.Java//核心代码

    package TSP;


    import java.io.File;
    import java.util.List;
    import java.util.Scanner;


    public class DP {
    //V集合表示已经旅行后的点的集合。
    //n点经过集合V中所有点到达起始点的最短距离;1<<(n-1)代表一个二进制串,
    //1代表该位置的城市在V集合例,反之不在。
    static double INF = Double.MAX_VALUE;
    static double[][] DT = null;
    static double[][] DP = null;
    // static int n = 0;
    static void init(int n) {
    File file = new File("E:\\Java\\arithmetic\\src\\resource\\att48.xls");
    List<city> cityList = inputData.input_att48(file);
    System.out.println("city [城市编号   城市X坐标    城市Y坐标]");
    for(int i=0; i<n; i++) {
    System.out.println(cityList.get(i).toString());
    }
    DT = new double[n][n];
    DP = new double[n][1<<(n-1)];
    for(int i=0; i<n; i++) {
    for(int j=i; j<n; j++) {
    if(i==j) DT[i][j] = 0;
    else {
    double dertX = cityList.get(i).getX()-cityList.get(j).getX();
    double dertY = cityList.get(i).getY()-cityList.get(j).getY();
    DT[i][j] = Math.sqrt(dertX*dertX + dertY*dertY);
    DT[j][i] = DT[i][j];
    }
    }
    }

    // for(int i=0; i<n; i++) {
    // for(int j=0; j<n; j++) {
    // System.out.print(DT[i][j]);
    // System.out.print(" ");
    // }
    // System.out.println();
    // }

    //V集合为空的情况,初始化第i点直接回到起点s的距离
    for(int i=1; i<n; i++) {
    DP[i][0] = DT[i][0];
    }
    }

    static void solve(int n) {
    double minDt = INF;
    double temp = 0;
    for(int j=1; j<1<<(n-1); j++){//j的二进制表示V集合。
            for(int i=1; i<n; i++){//n个点减去起点还有n-1个点,遍历n-1个点选一个不在集合V中的点。
                if((1<<(i-1)&j)==0){//(1<<(i-1))&j==0表示i不在集合v中
                    minDt = INF;
                    for(int k=1; k<n; k++){
                        if(((1<<(k-1))&j)!=0){//(1<<(k-1))&j==1表示k在集合V中
                            temp = DT[i][k] + DP[k][j-(1<<(k-1))];
                            if(temp < minDt) minDt = temp;
                        }
                    }
                }
                DP[i][j] = minDt;
            }
        }
    minDt = INF;
        for(int k=1; k<n; k++){//1<<(9)=1000000000,((1<<(n-1))-1)=111111111111...
            temp = DT[0][k] + DP[k][((1<<(n-1))-1)-(1<<(k-1))];
            if(temp < minDt){
                minDt = temp;
            }
        }
        System.out.print("最短路径长:");
        System.out.println(minDt);
    }

    @SuppressWarnings("resource")
    public static void main(String[] args) {
    // TODO Auto-generated method stub
    System.out.println("----------------动态规划解决TSP问题----------------");
    Scanner in = new Scanner(System.in);
    while(true) {
    System.out.println();
    System.out.println("请输入城市数:");
    int n = in.nextInt();
    if(n>24) {
    System.out.println("城市数过多,请使用其他算法!");
    return;
    }
    init(n);
    solve(n);
    }
    }
    }

    输入输出:


    展开全文
  • 经典算法问题-TSP商旅问题(Traveling Salesman Problem),它是数学领域中著名问题之一。...代码包含遗传算法动态规划来求解这个问题,里面有完整源代码,并且有详细注释,还有两者的比较分析。
  • 此ppt介绍了解决TSP(旅行商问题)的三种算法动态规划、蚁群算法、遗传算法
  • 您可以将集合编码为整数:整数的第i位表示第i个城市的状态(即,我们是否将其放入子集中)。例如,3510=1000112将表示城市{1,2,6}。这里我从最右边的一位开始计数,代表城市1。在为了使用子集的这种表示来索引列表,...

    您可以将集合编码为整数:整数的第i位表示第i个城市的状态(即,我们是否将其放入子集中)。

    例如,3510=1000112将表示城市{1,2,6}。这里我从最右边的一位开始计数,代表城市1。在

    为了使用子集的这种表示来索引列表,您应该创建长度为2n的二维数组:# Assuming n is given.

    A = [[0 for i in xrange(n)] for j in xrange(2 ** n)]

    这是因为使用n位整数可以表示{1,2,…,n}的每一个子集(请记住,每一位正好对应于一个城市)。在

    此表示为您提供了许多不错的可能性:

    ^{pr2}$

    这是我如何实现您的伪代码(警告:没有进行测试):# INFINITY and n are defined somewhere above.

    A = [[INFINITY for i in xrange(n)] for j in xrange(2 ** n)]

    # Base case (I guess it should read "if S = {1}, then A[S, 1] = 0",

    because otherwise S = {0} is not a valid index to A, according to line #1)

    A[1][1] = 0

    # Iterate over all subsets:

    subsets = range(1, 2 ** n)

    for subset in sorted(subsets, key=lambda x: bin(x).count('1')):

    if not subset & 1:

    # City #1 is not presented.

    continue

    for j in xrange(2, n + 1):

    if not (1 << (j - 1)) & subset:

    # City #j is not presented.

    continue

    for k in xrange(1, n + 1):

    if k == j or not (1 << (k - 1)) & subset:

    continue

    A[subset][j] = min(A[subset][j], A[subset ^ (1 << (j - 1))][k] + get_dist(j, k))

    除了拥有实现伪代码所需的所有功能外,这种方法比tuples\dicts更快。在

    展开全文
  • TSP问题动态规划

    万次阅读 多人点赞 2018-05-15 20:19:10
    (一)动态规划法 假设从顶点i出发,令d(i, V')表示从顶点i出发经过V'中各个顶点一次且仅一次,最后回到出发点i的最短路径长度,开始时,V'=V-{i},于是,TSP问题动态规划函数为:d(i,V')=min{cik+d(k,V-{k}...

        TSP问题是指旅行家要旅行n个城市,要求各个城市经历且仅经历一次然后回到出发城市,并要求所走的路程最短。各个城市间的距离可以用代价矩阵来表示。

        假设从顶点i出发,令d(i, V')表示从顶点i出发经过V'中各个顶点一次且仅一次,最后回到出发点i的最短路径长度,开始时,V'=V-{i},于是,TSP问题的动态规划函数为:

    d(i,V')=min{cik+d(k,V-{k})}(k∈V')

    d(k,{})=cki(k≠i)

        伪代码:

    for (i=1; i<n; i++)     //初始化第0列
    	d[i][0]=c[i][0]; 
     for (j=1; j<2n-1-1; j++)  
     	for (i=1; i<n; i++)   //依次进行第i次迭代
    		if (子集V[j]中不包含i) 
     			对V[j]中的每个元素k,计算[i][j]=min(c[i][k]+d[k][j-1]);
    对V[2n-1-1]中的每一个元素k,计算d[0][2n-1-1]=min(c[0][k]+d[k][2n-1-2]);
    输出最短路径长度d[0][2n-1-1];
    

        笔者在写此程序时卡在了如何判断:子集V[j]中不包含i。解决方法是对n个顶点分别用0~n-1的数字编号,按个数为1,2,……,n-1的顺序生成1~n-1个元素的子集存放在数组V[2^n-1]中。这样,在判断时就可以将当前点与数组编号按位与运算(如下图所示),为0则为需要进行计算(这时才能品味按位与运算的美)。


        完整代码:

    #include<iostream.h>
    #include<math.h>
    int main()
    {
    	int i,j,k,min,brief,n;
    	int D[20][20];
    	cout<<"顶点个数:";
    	cin>>n;
    	int b=(int)pow(2,n-1);
      	for(i=0;i<n;i++)
        	for(j=0;j<n;j++)
          		cin>>D[i][j];
      	int ** Route = (int **)calloc(n, sizeof(int *));
      	int ** Mat = (int **)calloc(n, sizeof(int *));
      	for(i=0;i<n;i++)
      	{
        	Route[i] = (int *)calloc(b*b, sizeof(int))+i*b;
        	Mat[i] = (int *)calloc(b*b, sizeof(int))+i*b;
      	}
      	for(i=0;i<b;i++)
       		for(j=0;j<n;j++)
    	    {
    			Route[j][i] = -1;
       			Mat[j][i] = -1;
    	    }
      	for(i=0;i<n;i++)//初始化第0列 
        	Route[i][0] = D[i][0];    
      	for(i=1;i<b-1;i++)
    	    for(j=1;j<n;j++)//依次进行第i次迭代 
    			if( ((int)pow(2,j-1) & i) == 0)//子集V[j不包含i 
    			{
    				min=999;
    				for(k=1;k<n;k++)
    				if( (int)pow(2,k-1) & i )
    				{
    					brief = D[j][k] + Route[k][i-(int)pow(2,k-1)]; 
    					if(brief < min)
    					{
    						min = brief;
    						Route[j][i] = min;
    						Mat[j][i] = k;//局部最优决策
    					}
    				}    
    			}
    	min=999;
      	for(k=1;k<n;k++)
    	{
    		brief = D[0][k] + Route[k][b-1 - (int)pow(2,k-1)];
    		if(brief < min)
    		{
    			min = brief;
    			Route[0][b-1] = min;//最优解
    			Mat[0][b-1] = k;
    		}
    	}
    	cout<<"最短路径长度:"<<Route[0][b-1]<<endl;//最短路径长度
    	cout<<"最短路径:"<<"1";
    	for(i=b-1,j=0; i>0; )
    	{
    		j = Mat[j][i];
    		i = i - (int)pow(2,j-1);
    		cout<<"->"<<j+1;
    	}
    	cout<<"->1"<<endl;
    	for(i=0;i<n;i++)
    	{
    		for(j=0;j<b;j++)
      			cout<<Route[i][j]<<" ";
    		cout<<endl;
    	}
    	free(Route);
    	free(Mat);
    	return 0;
    }
    
    展开全文
  • 本压缩文档包含三个文件:用动态规划法解决TSP问题可执行源代码,word文档报告,实验测试数据
  • 旅行商问题动态规划matlab代码这是解决经典TSP的三种不同方法,即。 所有代码都在MATLAB 2019b上进行了测试。 算法是 遗传算法(边缘表示和2-opt) 动态编程 群算法(蚂蚁系统算法) 怎么跑 在遗传算法和群算法中,...
  • 本介绍用python解决TSP问题的第二个方法——动态规划法算法介绍动态规划算法根据的原理是,可以将原问题细分为规模更小的子问题,并且原问题的最优解中包含了子问题的最优解。也就是说,动态规划是一种将问题实例...

    本介绍用python解决TSP问题的第二个方法——动态规划法

    算法介绍

    动态规划算法根据的原理是,可以将原问题细分为规模更小的子问题,并且原问题的最优解中包含了子问题的最优解。也就是说,动态规划是一种将问题实例分解为更小的、相似的子问题,并存储子问题的解而避免计算重复的子问题,以解决最优化问题的算法策略。

    我使用DP求解TSP问题的主要分为三个主要部分:

    1)     假定我们从城市0出发,经过了所有城市,并返回到城市0。那么我们需要记录的信息有:当前所在城市location,当前未遍历的城市集合s。

    2)     状态转移方程,状态转移方程是DP算法的核心部分,它代表了子问题和原问题的关系,通过状态转移方程可以将原问题不断细分为各个子问题。我们状态转移方程的定义如下所示:

    T(s,init)代表的意思是从init点出发经过s中全部的点回到init的距离。

    3)     构建T表记录T的值,如果不去记录每次递归的T值,那么以后每次搜索都要重新计算,就成了暴力搜索。所以我们构建一个T表dp[s][init],记录每次求出来的T函数值,即将T(s,init)的值记录在dp[s][init]位置。

    程序

    输入:

    1 2066 2333

    2 935 1304

    3 1270 200

    4 1389 700

    5 984 2810

    6 2253 478

    7 949 3025

    8 87 2483

    9 3094 1883

    10 2706 3130

    代码:

    """

    动态规划法

    name:xxx

    date:6.8

    """

    import pandas as pd

    import numpy as np

    import math

    import time

    dataframe = pd.read_csv("./data/TSP10cities.tsp",sep=" ",header=None)

    v = dataframe.iloc[:,1:3]

    train_v= np.array(v)

    train_d=train_v

    dist = np.zeros((train_v.shape[0],train_d.shape[0]))

    #计算距离矩阵

    for i in range(train_v.shape[0]):

    for j in range(train_d.shape[0]):

    dist[i,j] = math.sqrt(np.sum((train_v[i,:]-train_d[j,:])**2))

    """

    N:城市数

    s:二进制表示,遍历过得城市对应位为1,未遍历为0

    dp:动态规划的距离数组

    dist:城市间距离矩阵

    sumpath:目前的最小路径总长度

    Dtemp:当前最小距离

    path:记录下一个应该到达的城市

    """

    N=train_v.shape[0]

    path = np.ones((2**(N+1),N))

    dp = np.ones((2**(train_v.shape[0]+1),train_d.shape[0]))*-1

    def TSP(s,init,num):

    if dp[s][init] !=-1 :

    return dp[s][init]

    if s==(1<

    return dist[0][init]

    sumpath=1000000000

    for i in range(N):

    if s&(1<

    m=TSP(s&(~(1<

    if m

    sumpath=m

    path[s][init]=i

    dp[s][init]=sumpath

    return dp[s][init]

    if __name__ == "__main__":

    init_point=0

    s=0

    for i in range(1,N+1):

    s=s|(1<

    start = time.clock()

    distance=TSP(s,init_point,0)

    end = time.clock()

    s=0b11111111110

    init=0

    num=0

    print(distance)

    while True:

    print(path[s][init])

    init=int(path[s][init])

    s=s&(~(1<

    num+=1

    if num>9:

    break

    print("程序的运行时间是:%s"%(end-start))

    结果:

    展开全文
  • 问题描述不展开了,感兴趣可以自己搜一下。csdn上这篇文章介绍的很详细,可以看一下 ,http://blog.csdn.net/q345852047/article/details/6626684 感谢作者辛勤码字,我就偷懒啦~1.贪心"""Functions:find_path:Data...
  • 粒子群算法解决TSP问题,路径规划 matlab代码
  • TSP动态规划实现

    2014-08-15 18:30:21
    TSP动态规划实现,代码是我从网上找到的,找了好几天,我觉得写的很不错
  • 解决tsp问题,matlab代码,基于蚁群算法,保障算法正确性和有效性。
  • DP 保证向 TSP 提供准确(最佳)结果,但该算法的时间复杂度为 O(2^nn^2),这限制了使用这个算法到 15 个城市或更少。 注意:为了合理的运行时间,请不要尝试计算超过 13 个城市的游览。 DP 不适用于大型城市。
  • TSP问题——动态规划

    2020-12-23 11:30:22
    ) ,我们这里采用的动态规划算法, 算法复杂度已经从阶乘级降到了o( ( n^2 )*( 2^n ) ) (看起来也是相当恐怖的,不过像这种经典难题这种复杂度对我来说已经不错了)。 开始说说思路,一开始马上想到的必然是搜索,...
  • 动态规划法解旅行商问题TSP问题的java实现
  • 能够使用C++语言编写出一个程序,这个程序能够实现一个功能,就是在网络 上找一条从 点出发,经过 各一次最后返回 的最短路线和最短路程。就是要求解决一个TSP问题
  • 动态规划问题使用GA和PSO算法求解10个城市TSP问题动态规划
  • 动态规划法】求解TSP问题

    千次阅读 多人点赞 2019-07-14 23:50:18
    假设从顶点i出发,令d(i, V’ )表示从顶点i出发经过V’ 中各个顶点一次且仅一次,最后回到出发点(i)的最短路径长度,开始时, V’ =V-{i},于是,TSP问题动态规划函数为: d(i, V’ )=min{cik+d(k, V’ -{k})...
  • 2 动态规划思想 1 出发城市:0 ;经过{1,2,3}各城市有且仅有一次,再回到出发城市0 2 dp[i]{v}:表示从城市i出发,经过集合v,回到出发点0 的最段路径 3 最后结果dp[0]{1,2,3}; dp[0]{1,2,3}=min(dis[0][1]+dp[1]{...
  • 算法设计与分析实验报告,...问题描述:矩阵连乘算法实现; 给定n个矩阵{A1,A2,…,An},其中Ai与Ai+1是可乘的,i=1,2…,n-1。如何确定计算矩阵连乘积的计算次序,使得依此次序计算矩阵连乘积需要的数乘次数最少。
  • 最近在做毕业设计,从0学习了matlab和一些启发式算法,其中有个部分为tsp问题,思来想去想复现参考论文中的动态规划求解,网上看了一些资料,代码都是c++或者java的,这里分享下自己用matlab写的代码: 注:参考资料...
  • TSP问题三种算法

    热门讨论 2012-06-14 19:47:19
    实现一个能够演示解决货郎担问题的小...城市节点数目从5、10、20、40做不同变化,观察不同节点数目下,算法运行效率和运行结果的变化趋势。软件应该给出每一个搜索步骤,最后标示出完整的解路径,并指明是否为最优解。
  • 前言:这门课程教材为清华出版社的算法设计与分析第二版,这本书上的代码,以及学校实验,实验报告,PTA实验编程题等资源,我都会放在Gitee仓库中。 new(albert)/算法分析与设计 /* * @Description: * @version: * ...
  • TSP问题-多种算法求解

    千次阅读 多人点赞 2020-06-25 18:22:24
    动态规划法(少城市) 回溯法(中等规模城市数量) Sherwood概率算法改进版(随机第一个城市) 共8种算法(加粗的用于求解问题) 第一次发博客,如有错误,希望大佬们指正! 问题及思路   1.问题概述 TSP问题是...
  • } int TSP(){ for (int i = 1; i ; ++i) {//初始化第0列,i为行数 distanceTable[i][0] = distanceMatrix[i][0]; } //第一步,先不填最后一个空,先填前面的 for (int j = 1; j (int)pow(2,N - 1); ++j) {//从第一列...
  • 算法设计中的TSP问题的蛮力法、动态规划法、贪心法及回溯法。
  • 想分享的是递归实现的一种思路,理解了动态规划求解TSP的基本原理之后,会发现,计算相邻两个状态的距离d可以同归递归求解。
  • 旅行家要旅行5个城市,要求各个城市经历且仅经历一次然后回到出发城市,并要求所走的路程最短,其代价矩阵如下(INF表示不可达) 试求出最小代价,并输出对应的路径。
  • TSP问题之线性规划算法

    千次阅读 2020-05-15 22:35:02
    用线性规划的思想求解TSP的较优H圈。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,130
精华内容 1,252
关键字:

tsp问题动态规划算法