TSP旅行商问题

TSP是啥呢？通俗地讲，这个问题可以描述为一个商品推销员要去若干个城市推销商品，该推销员从一个城市出发，需要经过所有城市后，回到出发地。应如何选择行进路线，以使总的行程最短。所以就是在一个图中从一个点出发，找一个回路，能够回到这个点，而且总花销还最小。那我们怎么做呢？这篇文章我们用动态规划来写。

首先，请看一下bilibili上关于动态规划过程的描述，这是我们实现算法的基础：

 

 

 

 我认为这两张图就比较通俗易懂了。我们从城市0出发，经过城市1,2,3最后回到城市0所花费的代价，是三个小代价的最小值，这三个小代价是什么呢？是城市0到城市1的距离，加上从城市1出发，经过城市2,3，最后回到城市0的距离，...后面以此类推，递推式已经写在上面了。因此，这个递推式就是我们实现递归的核心，我们需要不断更新d这个城市的集合（说白了，就是不断把它里面的城市从它里面剔除，一次剔除一个），这样，递归到最后，城市集合为空。这时候怎么办呢？别急，上面的式子里面也写了。递归到最后，我就只需要算集合外面那个城市（定义的是d(city，collection)，这里集合外面的城市就指的是d的city）到城市0的距离即可，也就是说，直接把这个距离返回。这样，我们写代码的思路就出来了。然后再在前面做一些初始化的工作就可以了。

下面贴代码：

第一步，我们定义几个变量：

public int[][] dis;
public ArrayList<Integer> cities;
public int source;

第一行的二维数组dis存储的是距离，比如dis[i][j]表示的是从城市i到城市j的距离；

第二行的是集合，存储的是城市。由于城市我们以数字编号，因此使用了一个Integer类型的ArrayList集合；

第三行是源点，即城市0.

然后我们在构造器里来个初始化：

public Traveling(int n) {
        cities = new ArrayList<>();
        for (int i = 0; i < n; ++i) {
            cities.add(i);
        }
        source = 0;
}

在cities集合里添加全部的城市，这里城市编号从0开始。

然后我们写一个init方法，用来初始化dis数组，以什么样的标准呢？城市自己到自己的距离当然就是0啦，除此之外，全部设为正无穷。

public void init() {
        int n = dis.length;
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                dis[i][j] = ((i == j) ? 0 : Integer.MAX_VALUE);
            }
        }
}

然后，为了实现后面递归代码里面城市集合几种不同的情况，我们写一个复制集合的方法（否则会炸，因为java不允许边迭代集合的时候还边对它里面的元素进行修改）：

private ArrayList<Integer> copy(ArrayList<Integer> a) {
        ArrayList<Integer> list = new ArrayList<>();
        for (Integer i : a) {
            list.add(i);
        }
        return list;
7 }

最后，我们写一个distance函数，其实也就是tsp动态规划的过程：

private int distance(int start, ArrayList<Integer> list) {
        if (list.size() == 0) {
            return dis[start][source];
        } 
        int temp = Integer.MAX_VALUE;
        for (Integer i : list) {
            ArrayList<Integer> copied = copy(list);
            copied.remove(i);
            int res = distance(i, copied) + dis[start][i];
            temp = temp < res ? temp : res;
        }
        return temp;
13 }

首先，我们要定义递归函数的退出条件，即:城市集合为空时，我们应直接返回距离。

其次，遍历城市集合里面所有的城市，分别把它们挑出来，计算哪种花费的代价最小。我们就选那个，最后，把这个最小代价返回。

最后我们给外界提供一个方法：

public int tsp() {
        return distance(source, cities);
}

来一波完整代码：

package com.hw.others;

import java.util.ArrayList;
import java.util.Scanner;

public class Traveling {
    public int[][] dis;
    public ArrayList<Integer> cities;
    public int source;

    public Traveling(int n) {
        cities = new ArrayList<>();
        for (int i = 0; i < n; ++i) {
            cities.add(i);
        }
        source = 0;
    }

    public void init() {
        int n = dis.length;
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                dis[i][j] = ((i == j) ? 0 : Integer.MAX_VALUE);
            }
        }
    }

    private ArrayList<Integer> copy(ArrayList<Integer> a) {
        ArrayList<Integer> list = new ArrayList<>();
        for (Integer i : a) {
            list.add(i);
        }
        return list;
    }

    private int distance(int start, ArrayList<Integer> list) {
        if (list.size() == 0) {
            return dis[start][source];
        } 
        int temp = Integer.MAX_VALUE;
        for (Integer i : list) {
            ArrayList<Integer> copied = copy(list);
            copied.remove(i);
            int res = distance(i, copied) + dis[start][i];
            temp = temp < res ? temp : res;
        }
        return temp;
    }

    public int tsp() {
        return distance(source, cities);
    }

    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        System.out.println("输入城市个数:");
        int n = s.nextInt();
        Traveling traveler = new Traveling(n);
        traveler.dis = new int[n+1][n+1];
        traveler.init();
        System.out.println("输入边的数目:");
        int edge = s.nextInt();
        System.out.println("现在输入城市与城市间的距离(城市编号从0开始):");
        for (int i = 0; i < edge; ++i) {
            int start = s.nextInt();
            int end = s.nextInt();
            int weight = s.nextInt();
            traveler.dis[start][end] = weight;
            traveler.dis[end][start] = weight;
        }
        int length = traveler.tsp();
        System.out.println("最短路径代价为:" + length);
        s.close();
    }
}