浅谈可重复访问城市的TSP问题(最短距离 + 具体走法)

最新推荐文章于 2024-06-30 15:07:14 发布
最新推荐文章于 2024-06-30 15:07:14 发布
阅读量5k 收藏 45
点赞数 34
分类专栏： 算法 文章标签： 算法 动态规划 tsp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ernie_linyerun/article/details/120695404
版权

小伙伴们，你们好。今天我来浅显的讲一下这个可重复访问城市的TSP问题，所谓的可重复就是城市和路线都随便走，只要最后它的路径总和是最小的就行。

要用到的知识点是 状态压缩dp 和 Floyd算法

一、Floyd算法

Floyd算法：floyd算法学习视频
这个小姐姐会用手算的方式带你了解floyd算法的整个过程，相信看完你就有一种恍然大悟的感觉了

我下面floyd算法的主要作用是让我们得到一个距离二维数组，路径二维数组

1.distance[][]

例子:distance[i][j] 表示点i到点j的最短距离
有了这个数组，我们第一步就完成了

2.path[][]

例子：path[i][j]表示点i到点j中间经过了什么点

	public void floyd(Double[][] distance,int[][] path,Double[][] edge) {
        int n = edge.length;//edge数组是一个邻接矩阵
        //初始化一下传进来距离数组
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                path[i][j] = -1;
                if (i!=j) {
                    distance[i][j]  = edge[i][j];
                }else {
                    distance[i][j] = 0.0;
                }
            }
        }
        //核心算法
        for (int k=0;k<n;k++) {
            for (int i=0;i<n;i++) {
                for (int j=0;j<n;j++) {
                    if (distance[i][j]>distance[i][k]+distance[k][j]) {
                        distance[i][j] = distance[i][k]+distance[k][j];
                        path[i][j] = k;//记录路径的数组
                    }
                }
            }
        }
    }

通过调用函数jointPath(…)我们就可以找到v0=>v的完整路径了，这对我们求TSP的路径也是至关重要的

//int[][] path:由floyd得到
//v0:起点，v:终点
//idx[0]:因为我要记住p数组的有效长度，所以用了idx[0]来保证它可以当指针用
//ps:我有点菜，写得不是很好
    public void jointPath(int[][] path,int v0,int v,int[] p,int[] idx) {
        getPath(path,v0,v,p,idx);
        p[idx[0]++] = v;
    }
    //好好用纸来模拟一下这个递归函数，你就悟了
	public void getPath(int[][] path,int v0,int v,int[] p,int[] idx) {
        if (path[v0][v]==-1) {
            p[idx[0]++] = v0;
            return;
        }
        getPath(path,v0,path[v0][v],p,idx);//左边
        getPath(path,path[v0][v],v,p,idx);//右边
    }

写完博客，我会录制视频在b站，你们可以关注一下我，看一下我的视频讲解 : 随风的叶子(我的账号名称)

二、状态压缩dp

视频学习连接，看前33分钟就行
这个视频里面，他会教你dp的概念还有怎么使用与、或、非和异或
这老师讲得还是十分详细的，里面讲解的题目：最短Hamilton路径
这道题和我们要解决的问题有着异曲同工之妙，能够解决上面的这道题，相信下面你们快速的掌握。

欢迎回来，相信你对dp有一定了解了.

下面，我们要有这样一种思维：就是我们只注重点i到点j的最短距离，就是我们把心放在distance[][]数组上面，我们无需关系i到j之间通过了什么点，所以我们dp集合加入了i和j,那么i和j之间包含1了什么点我们不管，也不会加入到dp集合中，我们关心的只有最短，因为点和边是可以重复的

你应该get到我的点了吧

接下来，我就和你讲讲这道题的具体思路：

首先我们开一个dp[1<<n][n]的数组

因为我们要表示每个集合的状态，而状态有0~111…111(2^n-1)

当我们成功的将我们的状态搞到111…111(2^n-1)就是我们胜利的时刻了

下面，我来上代码来说话(要认真看我的注释噢)

dp[s][i] = Math.min(dp[s][i],dp[s^(1<<i)][j]+distance[j][i]);//只是至关重要的，这玩意的作用就是假如还没有将顶点i加入集合中（实际我们已经加入了），通过存在集合当中的顶点j为踏板来到i的距离会不会比原来的距离要短

然后，我还是想和大家说一下
ps: 以下从第0位开始

  • s&(1<<i) 例子:假如s:1101(2进制),i=2(10进制),1<<i=100(2进制)，这时1101&0100 = 0100,然后我们就可以通过判断s&(1<<i) 等不等于0来确定s(2进制)第i位是0还是1了
  • s^(1<<i) 例子，假如s:1101(2进制),i=2(10进制),1<<i=100(2进制)，这时1101 ^ 0100 = 1001(我们就可以将s(2进制)的第i位变成0了)
 //==================状态压缩DP
        Double[][] dp = new Double[1<<n][n];//开数组
        //初始化dp数组
        for (int i = 0; i < 1<<n; i++) {
            for (int j = 0; j < n; j++) {
                dp[i][j] = Double.MAX_VALUE;
            }
        }
        dp[1][0] = 0.0;//将0号点放进集合里面,0:表示当前在点0处停留
        for (int s=1;s<(1<<n);s++) {//1~11..11(2^n-1[1<<n])
            for (int i=0;i<n;i++) {
                if ((s&(1<<i))!=0) {//顶点i加入了集合当中
                    for (int j = 0; j < n; j++) {
                        if ((s&(1<<j))!=0&&i!=j) {
                            dp[s][i] = Math.min(dp[s][i],dp[s^(1<<i)][j]+distance[j][i]);
                        }
                    }
                }
            }
        }
        Double ans = Double.MAX_VALUE;//初始化一下
        //最后，我们将所有的点都加入了集合当中，那么我们从最后加入的那个点回到原点就大公告成了，从一个点到另一个点的最短距离我们还是从distance[][]里面获取
  //也是这里启示我自己想出来了求路径的方法
        for (int i=1;i<n;i++) {//0是起始点，就不要加入里面了
            if (ans > dp[(1<<n)-1][i]+distance[i][0]) {
                ans = dp[(1<<n)-1][i]+distance[i][0];
            }
        }
        return n==1?0:ans;//健壮性

下面有必要声明一下：
@Autowired
private FloydUtil floydUtil;（这玩意是因为我写springboot项目用了，你们看到函数名知道我在放什么屁就行了，抱拳了）

  • public void TSP_can_repeat_path(Double[][] dp,Double[][] dis,int[] path,int end,int n)
  • public void completePath(int[][] path,int[] p,int[] initP,int[] idx)

ps:参数具体什么含义，看我注解就知道了

  • 我先说一下我第一个算法的作用，现有状态s就是不断的回退状态t，然后找到状态t到状态s的最短路径来确定点（再重复一遍：我这里i->j，可能里面还包含了别的点，只是我们通过两点的最短路路径看成它们相通罢了）

在这里插入图片描述
在这里插入图片描述

看这张图：箭头右边的数组表示第i位变位0了，当最后集合变成0就是我们胜利的时刻了（重复一次：从第0位开始）

if (index==-1) break;//结束条件，你也可以自己优化一下，反正我就爱这么写[哈哈],当下标没有变化的时候就结束了

这个时候，我们只是成功了一半，

0   1   2   3   13   14   15   12   4   11   16   11   5   6   5   10   17   18   9   19   8   7 0

再再再重复一遍：0=>1或者 10=>7,表示的只是最短路径，我们还要将他们中间存在的点找出来，这个时候的找我们就回到floyd算法里面涉及的找路径，我们通过一个for就能全部找出来了，

floydUtil.getPath(…)：我这里这个函数不会将它最后一个元素加入数组中

认真看下面的代码就理解整个过程了，期待我在b站把视频肝出来吧

//求出路径
	/**
     *
     * @param p  (完整路线数组)
     * @param iii (上面数组的有效下标)
     * @param n   (顶点个数)
     * @return   (返回路径最小值)
     */
    public void TSP_can_repeat_path(Double[][] dp,Double[][] dis,int[] path,int end,int n) {//end从0开始
        int s = (1<<n)-1;//path数组的长度等于顶点的个数(11...111)
        int idx = 0;//初始化为0
        path[idx++] = end;//最后一个 去吧你
        //System.out.println(Integer.toBinaryString(s));//二进制，我要看看出现了什么幺蛾子
        while (true) {
            s = s^(1<<end);//新状态
            //System.out.println(Integer.toBinaryString(s)+"-->"+end);
            Double min = Double.MAX_VALUE;
            int index = -1;
            for (int i = 0; i < n; i++) {
                if ( (s&(1<<i))!=0 && min > dp[s][i]+dis[i][end]) {
                    min = dp[s][i]+dis[i][end];
                    index = i;
                }
            }
            if (index==-1) break;
            path[idx] = index;
            end = index;
            idx ++;
        }
        for (int i = 0; i < (n / 2) - 1; i++) {
            int tmp = path[i];
            path[i] = path[n-1-i];
            path[n-1-i] = tmp;
        }
    }

    /**
     *
     * @param path (floyd之后的路径)
     * @param p    (要填补的数组)
     * @param initP (上一层搞的路径)
     * @param idx    (记录下标)
     */
    public void completePath(int[][] path,int[] p,int[] initP,int[] idx) {
        int n = initP.length;
        for (int i = 0; i < n-1; i++) {
            int[] res =  new int[n];
            int[] index = new int[1];
            floydUtil.getPath(path,initP[i],initP[i+1],res,index);
            for (int j = 0; j < index[0]; j++) {
                p[idx[0]++] = res[j];
            }
        }
        p[idx[0]++] = initP[n-1];//最后一个点放进来

    }

下面是我写的完整代码

package com.lin.utils;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class FloydDPUtil {

    @Autowired
    private FloydUtil floydUtil;


    /**
     *
     * @param p  (完整路线数组)
     * @param iii (上面数组的有效下标)
     * @param n   (顶点个数)
     * @return   (返回路径最小值)
     */
    public Double TSP_can_repeat(int[] p,int[] iii,int n) {
        //==================floyd
        Double[][] distance = new Double[n][n];
        int[][] path = new int[n][n];
        floydUtil.floyd(distance,path);
        //==================状态压缩DP
        Double[][] dp = new Double[1<<n][n];
        //初始化dp数组
        for (int i = 0; i < 1<<n; i++) {
            for (int j = 0; j < n; j++) {
                dp[i][j] = Double.MAX_VALUE;
            }
        }
        dp[1][0] = 0.0;//将0号点放进集合里面
        for (int s=1;s<(1<<n);s++) {
            for (int i=0;i<n;i++) {
                if ((s&(1<<i))!=0) {//就是顶点i加入了集合当中
                    for (int j = 0; j < n; j++) {
                        if ((s&(1<<j))!=0&&i!=j) {
                            dp[s][i] = Math.min(dp[s][i],dp[s^(1<<i)][j]+distance[j][i]);
                        }
                    }
                }
            }
        }
        Double ans = Double.MAX_VALUE;
        int idx = -1;
        for (int i=1;i<n;i++) {//0是起始点，就不要加入里面了
            if (ans > dp[(1<<n)-1][i]+distance[i][0]) {
                ans = dp[(1<<n)-1][i]+distance[i][0];
                idx = i;
            }
        }
        //搞路径到数组initP里面
        int[] initP = new int[n+1];
        TSP_can_repeat_path(dp,distance,initP,idx,n);
        initP[n] = 0;
        //开始解析里面的东西,放到数组p中
        completePath(path,p,initP,iii);
        return ans;
    }

    //求出路径
    public void TSP_can_repeat_path(Double[][] dp,Double[][] dis,int[] path,int end,int n) {//end从0开始
        int s = (1<<n)-1;//path数组的长度等于顶点的个数(11...111)
        int idx = 0;//初始化为0
        path[idx++] = end;//最后一个 去吧你
        //System.out.println(Integer.toBinaryString(s));//二进制，我要看看出现了什么幺蛾子
        while (true) {
            s = s^(1<<end);//新状态
            //System.out.println(Integer.toBinaryString(s)+"-->"+end);
            Double min = Double.MAX_VALUE;
            int index = -1;
            for (int i = 0; i < n; i++) {
                if ( (s&(1<<i))!=0 && min > dp[s][i]+dis[i][end]) {
                    min = dp[s][i]+dis[i][end];
                    index = i;
                }
            }
            if (index==-1) break;
            path[idx] = index;
            end = index;
            idx ++;
        }
        for (int i = 0; i < (n / 2) - 1; i++) {
            int tmp = path[i];
            path[i] = path[n-1-i];
            path[n-1-i] = tmp;
        }
    }

    /**
     *
     * @param path (floyd之后的路径)
     * @param p    (要填补的数组)
     * @param initP (上一层搞的路径)
     * @param idx    (记录下标)
     */
    public void completePath(int[][] path,int[] p,int[] initP,int[] idx) {
        int n = initP.length;
        for (int i = 0; i < n-1; i++) {
            int[] res =  new int[n];
            int[] index = new int[1];
            floydUtil.getPath(path,initP[i],initP[i+1],res,index);
            for (int j = 0; j < index[0]; j++) {
                p[idx[0]++] = res[j];
            }
        }
        p[idx[0]++] = initP[n-1];//最后一个点放进来

    }

}

作者：随风

有什么问题可以私聊我qq:2338244917

你们可以关注我的b站账号：随风的叶子 跳转=>随风的叶子

我写完已经凌晨两点半了，还请给我点个赞
在这里插入图片描述
csdn粉丝数快突破300了，谢谢你们的支持

with the wind(随风)
关注
  • 34
    点赞
  • 踩
  • 45
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 5
    评论
专栏目录
可重复访问的有向TSP问题（C++）
ItaLink
06-04 1456
#include<iostream> #include<vector> #include<map> #include<queue> using namespace std; int node = 4; //假设有4个结点 map<string, map<string, int>> mp; ...
基于NN最近邻优化算法的TSP问题求解matlab仿真
FPGA/MATLAB学习教程/源码/项目合作开发
02-19 816
TSP是一个经典的组合优化问题，其目标是找到访问一组城市并返回起点的最短可能路线。在给定城市间距离的情况下，这个问题可以表述为找到一个排列，使得按照该排列顺序访问所有城市并返回起点的总距离最短。TSP问题是NP完全问题，这意味着在多项式时间内寻找全局最优解非常困难，除非P=NP问题得到解决。然而，存在多种近似算法和启发式方法来求得高质量的解，如最近邻算法、2-opt算法、模拟退火算法、遗传算法、分支定界法以及蚁群算法等。2.NN（最近邻）算法原理最近邻优化算法是一种贪心算法，用于求解TSP问题的近似解。
可重复访问城市的TSP问题
白学病患者的专栏
11-11 5319
TSP问题（旅行商问题）是指旅行家要旅行n个城市，要求各个城市经历且仅经历一次然后回到出发城市，并要求所走的路程最短。
HDU 5418 Victor and World (可重复走的TSP问题，状压dp)
weixin_30386713的博客
08-23 239
题意： 　　每个点都可以走多次的TSP问题：有n个点（n<=16），从点1出发，经过其他所有点至少1次，并回到原点1，使得路程最短。 思路： 　　给了很多重边，选最小的留下即可。任意点可能无法直接到达，所以先执行一次floyd，算出任意点对之间可达的最短距离。 　　（1）先考虑穷举的方法，将2~n个这n-1个数字的所有组合情况都算一遍，复杂度是 15！=...
php最短路径tsp,基于Matlab的蚁群算法求10个城市TSP问题的最短路径问题（附源码）...
weixin_35710893的博客
03-20 648
标签：设置过程命令sizeeps因子正是步骤nes基于蚁群算法的10个城市TSP问题的最短路径研究1 蚁群算法1.1 蚁群算法的流程步骤这里以TSP问题为例，算法设计的流程如下：步骤1：对相关参数进行初始化，包括蚁群规模、信息素因子、启发函数因子、信息素挥发因子、信息素常数、最大迭代次数等，以及将数据读入程序，并进行预处理：比如将城市的坐标信息转换为...
【编程练习】TSP问题与最短路径
Michelle
07-24 2852
TSP 暴力枚举法：此方法不适合城市个数>8的。时间复杂度成阶乘上升 #include <iostream> #include <cstdio> #include <cstring> using namespace std; #define maxx 9999 int l[maxx][maxx];//存储两个城市之间的距离 int n;//城市数量 int...
基于禁忌搜索算法的城市TSP问题matlab仿真+仿真录像
11-10
1.版本：matlab2021a，我录制了仿真操作录像，可以跟着操作出仿真结果 2.领域：城市TSP问题 3.内容：基于禁忌搜索算法的城市TSP问题matlab仿真，输出多个城市点的最优路径以及禁忌搜索的收敛曲线。
yiqun_城市最短路径问题_tsp_蚁群算法_
10-02
城市最短路径问题是一个经典的图论问题，它在交通规划、物流配送、网络设计等多个领域都有广泛应用。在本案例中，我们关注的是如何利用蚁群算法（Ant Colony Optimization, ACO）来解决这一问题。 蚁群算法是模拟...
基于使用蚁群算法求解TSP商旅问题的最短访问路线源码.zip
05-21
基于使用蚁群算法求解TSP商旅问题的最短访问路线源码.zip 【资源介绍】 使用蚁群算法求解TSP商旅问题的最短访问路线，其中使用2-邻边算法进行局部调整，可视化展示求解结果，附带实验报告说明。案例包括“五角星小型...
遗传算法 TSP 城市最短路径
04-13
总的来说，通过遗传算法解决TSP城市最短路径问题，需要理解算法的核心原理，合理设计适应度函数，以及优化参数设置。实际编程实现时，可以结合工具和源码，例如使用Python的NumPy库处理距离矩阵，以及利用matplotlib...
Tsp.zip_TSP最短路径_tsp_最短_最短路径
09-19
旅行商问题（Traveling Salesman Problem，简称TSP）是运筹学中一个著名的问题，它描述了一个旅行商如何有效地访问多个城市，每个城市只访问一次，最后返回起点，使得总行程距离最短。在实际应用中，这个问题广泛...
最短路径算法总结
Sc_Jn的博客
08-07 348
最短路径 知识： 如何知道2个点之间是否有边 如果是vector数组（领接表）保存的话，明确就是有边的 如果是用二维数组来保存的话，就需要判断g[i][j]是否是初始值 构图方法： 二维数组，用于Floyd F(i,1,m){ cin&gt;&gt;a&gt;&gt;b&gt;&gt;c; g[a][b]=g[b][a]=min(c,g[a][b...
TSP问题-可重复访问城市的解法
小夥的博客
08-23 5070
原TSP问题：某售货员要到若干城市去推销商品，已知各城市之间的路程（或旅费），他要选定一条从驻地出发，经过每个城市一遍，最后回到驻地的路线，使总路程（旅费）最小。 这里将原问题改为：每个城市可重复访问，要求使总路程最小。 思路分析：由于城市可以重复访问，从而任何状态下，由城市i到城市j没有路径上的限制，故从城市i到城市j必然选择路程最小的路径来走，可先用Floyd算法求出任意两城市之间
【python】TSP问题
清风微醺的博客
09-19 979
有一位商人，他想访问中国的某些城市，要求： 所走路程最近； 每个城市只能访问一次； 从某城市出发，最后回到该城市。 假设从合肥出发，最后回到合肥。 问题域：X={北京，成都，广州，上海} 目标函数：min f(x)=dist(合肥，city1) + ∑dist(cityi,cityj) + dist(cityj,合肥) 回溯算法，观察所有的路线 city = ['北京','成都','广州','上海'] def backtrack(first): if(first == len(cit
【回溯算法】旅行商问题--TSP问题
Woo~
04-12 9440
【问题描述】 一销售商从n个城市中的某一城市出发，不重复地走完其余n—1个城市并回到原出发点，在所有可能的路径中求出路径长度最短的一条。本题假定该旅行商从第1个城市出发。 输入 对每个测试例，第1行有两个整数：n(4≤n≤10)和m(4≤m≤20 ) ，n是结点数，m是边数。 接下来m行，描述边的关系，每行3个整数：(i，j)，length，表示结点i到结点j的长度是length。 当n＝0时，表示输入结束。 输出 对每个测试例，输出最短路径长度所经历的结点，最短的长度。 输入样例 4 6
基于蚁群算法的中国34个主要城市TSP问题（详细注释）
牵一只蜗牛去散步
03-03 4072
%% 清屏 clear, clc; %% 导入数据 citys = [116.46 39.92 117.2 39.13 121.48 31.22 106.54 29.59 91.11 29.97 87.68 43.77 106.27 38.47 111.65 40.82 108.33 22.84 126.63 45.75
TSP问题是指旅行家要旅行n个城市，要求各个城市经历且仅经历一次，并要求所走的路径最短。该问题又称为货郎担问题、邮递员问题、售货员问题，是图问题中广为人知的问题
CSDN 精品推荐
11-22 2679
1、问题描述 所谓TSP问题是指旅行家要旅行n个城市，要求各个城市经历且仅经历一次，并要求所走的路径最短。该问题又称为货郎担问题、邮递员问题、售货员问题，是图问题中广为人知的问题。 2、基本要求 （1）上网查找TSP问题的应用实例 （2）分析求TSP问题的全局最优解的时间复杂度 （3）设计一个球近似解的算法 （4）分析算法的时间复杂度 3、实现思想 利用贪心算法，从第一个节点遍历，不断寻找当时阶段的最优解，以达到最后所需的最优解 以下代码仅供参考 以下代码仅供参考 以下代码仅供参考 /** *
代码随想录-二叉搜索树①
最新发布
希希雾里
06-30 542
代码随想录-二叉搜索树①
常微分方程算法之编程示例六-解一阶方程组（龙格-库塔法）
欢迎各位大佬光临“寒舍”！请多多指点，共同进步！
06-27 367
主要对本专栏介绍的常微分方程差分格式进行算例补充。
tsp全球旅行最短距离
05-31
TSP（Traveling Salesman Problem，旅行商问题）是一个经典的组合优化问题，它的目标是找到一条路径，使得一位旅行商访问一组城市并返回起始城市的总路程最短。这个问题被证明是NP-hard问题，因此在实际中很难找到...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

with the wind(随风)

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值