货郎担问题（TSP问题）

货郎担问题也叫旅行商问题，即TSP问题（Traveling Salesman Problem），是数学领域中著名问题之一。

有n个城市，用1，2，…，n表示，城i,j之间的距离为dij，有一个货郎从城1出发到其他城市一次且仅一次，最后回到城市1，怎样选择行走路线使总路程最短？

货郎担问题要从图g的所有周游路线中求取具有最小成本的周游路线，而由始点出发的周游路线一共有（n一1）！条，即等于除始结点外的n一1个结点的排列数，因此货郎担问题是一个排列问题。通过枚举（n一1）！条周游路线，从中找出一条具有最小成本的周游路线的算法，其计算时间显然为o(n！）。

解货郎担问题：核心是动态规划，自底向上的思想。

下面是代码：我还没写出来……

哼哼：弄出来了

public class Main {

    private static int N = 6;          //此例中共有6个点
    private static int index = 1;      //货郎担问题 解的时候假定了第一个起始点就是0，所以从1开始
    private int x[] = new int[N];      //每个x[index] 存放的是位置为index 的点  比如index=0  x[1] = 2  位于位置1的点是 点2
    private static int bestX[] = new int[N];    //最优路径
    private int cLength = 0;                     //当前已经加入的点的长度
    private static int allLength = Integer.MAX_VALUE;    //总长
    private int weight[][] ={ {0,2,8,5,1,8},    
                                {3,0,1,8,5,2},
                                {6,2,0,3,6,1},
                                {88,3,6,0,6,4},
                                {7,2,6,1,0,5},
                                {6,3,9,1,4,0}};

    public static void main(String[] args) {
        Main tsp = new Main();
        tsp.getTSP(index);
        System.out.println(allLength);
        for (int i = 0; i < N; i++) {
            System.out.print(bestX[i]+"  ");
        }
    }
    private boolean ifExist(int index){                      //判断index这个位置上是否可以放x[index] 这个点
        int i=0;                                               //已经加入的位置  x[i]才是该位置的点
        while(i<index){                                        
            if(x[i]==x[index]){                                //判断当前位置的点是否已经出现了
                return false;
            }
            i++;
        }
        return true;
    }

    private void getTSP(int index){
        if(index==N-1){
            for(int j=1;j<=N;j++) {
                x[index] = Math.floorMod(x[index] + 1, N);         //通过取余弄出一个当前位置的点                                     
                if (ifExist(index) && cLength + weight[x[index - 1]][x[index]] + weight[x[index]][x[0]]< allLength) {    //总长= 已加入长度+ 到该点+该点到初始
                    allLength = cLength + weight[x[index - 1]][x[index]]+weight[x[index]][x[0]];
                    for (int i = 0; i < N; i++) {
                        bestX[i] = x[i];
                    }
                }
            }
        }else {
            for (int j = 1; j <= N; j++) {
                x[index] = Math.floorMod(x[index] + 1, N);  //给定当前这个位置的点的值
                if (ifExist(index) && cLength + weight[x[index - 1]][x[index]] < allLength) {
                    cLength += weight[x[index - 1]][x[index]];
                    getTSP(index + 1);
                    cLength -= weight[x[index - 1]][x[index]];
                }
            }
        }
    }

}

这是结果：