TSP问题是指旅行家要旅行n个城市，要求各个城市经历且仅经历一次，并要求所走的路径最短。该问题又称为货郎担问题、邮递员问题、售货员问题，是图问题中广为人知的问题

不要自卑，去提升实力
互联网行业谁技术牛谁是爹
如果文章可以带给你能量，那是最好的事！请相信自己
加油o~

1、问题描述

所谓TSP问题是指旅行家要旅行n个城市，要求各个城市经历且仅经历一次，并要求所走的路径最短。该问题又称为货郎担问题、邮递员问题、售货员问题，是图问题中广为人知的问题。

2、基本要求

（1）上网查找TSP问题的应用实例
（2）分析求TSP问题的全局最优解的时间复杂度
（3）设计一个球近似解的算法
（4）分析算法的时间复杂度

3、实现思想

利用贪心算法，从第一个节点遍历，不断寻找当时阶段的最优解，以达到最后所需的最优解

以下代码仅供参考
以下代码仅供参考
以下代码仅供参考

/**
 *作者：魏宝航
 *2020年11月22日,下午21:09
 */
import java.io.IOException;
import java.util.Scanner;

public class MatrixUDG {
     

    private char[] mVexs;       
    private int[][] mMatrix;    
    private int num;
    private int edge;

    public MatrixUDG(char[] vexs, char[][] edges) {
     
    
        num = vexs.length;
        edge = edges.length;

        mVexs = new char[num];
        for (int i = 0; i < mVexs.length; i++)
            mVexs[i] = vexs[i];

        mMatrix = new int[num][num];
        for(int i=0;i<num;i++){
     
            for(int j=0;j<num;j++){
     

            }
        }
        for(int i=0;i<edge;i++){
     
            for(int j=0;j<edge;j++){
     
                if(i==j){
     
                    mMatrix[i][j]=Integer.MAX_VALUE;
                }
                else{
     
                    mMatrix[i][j] = Integer.parseInt(edges[i][j] + "");
                }
            }
        }
    }

    public void print() {
     
        System.out.printf("Martix Graph:\n");
        for (int i = 0; i < mVexs.length; i++) {
     
            for (int j = 0; j < mVexs.length; j++){
     
                if(mMatrix[i][j]<Integer.MAX_VALUE){
     
                    System.out.printf("%d ", mMatrix[i][j]);
                }else{
     
                    System.out.print("∞ ");
                }
            }

            System.out.printf("\n");
        }
    }
    
    public int TSP(){
     
        int sum=0;
        boolean[] visit=new boolean[num];
        int min=Integer.MAX_VALUE;
        int now=0;
        int index=0;
        visit[0]=true;
        System.out.print(now+1);
        for(int k=0;k<num-1;k++){
     
            for(int i=0;i<mMatrix.length;i++){
     
                if(mMatrix[now][i]<=min&&visit[i]==false){
     
                    min=mMatrix[now][i];
                    index=i;
                }
            }
            visit[index]=true;
            sum+=min;
            now=index;
            min=Integer.MAX_VALUE;
            System.out.print("->"+(now+1));
        }
        sum+=mMatrix[now][0];
        System.out.print("->"+1);
        return sum;
    }

    public static void main(String[] args) {
     

        char[] vexs2={
     '1','2','3','4','5'};
        char[][] edges2=new char[][]{
     
                {
     '∞','3','3','2','6'},
                {
     '3','∞','7','3','2'},
                {
     '3','7','∞','2','5'},
                {
     '2','3','2','∞','3'},
                {
     '6','2','5','3','∞'},
        };
        MatrixUDG pG=new MatrixUDG(vexs2,edges2);
        pG.print();
        int sum=pG.TSP();
        System.out.println();
        System.out.println("最短路径为："+sum);
    }
}