旅行商问题（笔记）

介绍：

现在假设有4个城市，到各个城市都有一定的花费，你是一个旅行商要到这4个城市去售卖物品，这4个城市必须都走一遍，问走哪条路线花费最少？（起点可任意，最终要回到起点）

---

分析：

经过分析有以下这几种路线（假设从北京开始）：

我们可以看到，如果有4个城市的话，路线一共有：3x2 = 6 条， 5个城市有：4x3x2 = 24条，假设有n个城市，总路线就有：(n - 1)! 条， 时间复杂度很高，如果只有4、5个城市时，可以用动态规划来求解，这种时间消耗可以接收。

但如果更多的城市就只能考虑求近似解了。

我们可以用一张二维表来表示花费，行和列都代表城市编号，二维表格中的元素代表从某个城市到另一个城市的花费。如下图（graph）：

d(出发城市，剩余城市集合) ==> 从出发城市开始，走完剩余城市，花费的最少代价

我们可以得到以下递推公式：

我们可以把出发城市用变量 i 代替，剩余城市集合用 j 代替， 遍历 j 时的变量为 k （剩余的某一个城市）

旅行商问题要分多条路线，我们需要在这写众多路线中求解花费最小的，这其实就是一个把大问题拆解成很多子问题的过程。

注意：

动态规划思想就是找出递推公式，将当前问题分解成子问题，分阶段进行求解，在求解过程中缓存子问题的解，避免重复计算。

这次我们需要创建一张二维表格，表格的行代表每个城市，列代表剩余城市的集合，比如说从0号城市出发，还需要去1、2、3号城市，集合里装的就是这些城市。这里数组的列元素是一个集合，没怎么见过 ，像这样：

我们可以用二进制数来表示集合中是否存在这个城市，比如说 000 代表没有城市，001 代表有1号城市：

       

这样我们就可以用 十进制数来表示集合中有几个城市。

代码分析：

如果我们求解 d（0，1 | 2 | 3），我们需要知道之前的子问题的解，从3种情况中选择花费最小的填上去，推导是从右往左进行的，但是填二维表要从左往右填充。

我们第0列的元素是可以根据graph表格直接填充的。先初始化二维表：

static int tsp(int[][] g){
        int m = g.length;  //城市个数
        int n = 1 << (m - 1); //剩余城市的组合数
        int[][] dp = new int[m][n];
        //填充第0列
        for (int k = 0; k < m; k++) {
            dp[k][0] = g[k][0];
        }
        return 0;
    }

然后我们再填充后续列：

填充时，我们需要排除不合理的情况，比如出发点是0号城市，剩余城市里包含出发城市这种情况不做处理。我们可以先给一个比较大的值，如果后面有更小距离可以替换。

核心代码（根据这张图理解一下）：

static int tsp(int[][] g){
        int m = g.length;  //城市个数
        int n = 1 << (m - 1); //剩余城市的组合数
        int[][] dp = new int[m][n];
        //填充第0列
        for (int k = 0; k < m; k++) {
            dp[k][0] = g[k][0];
        }
        //填充后续列
        for (int j = 1; j < n; j++) {
            for (int i = 0; i < m; i++) {
                dp[i][j] = Integer.MAX_VALUE / 2;  //不要给太大，后面做运算可能会产生整数溢出
                if(contains(j, i)) continue; //剩余城市包含出发城市直接跳过（不合理）
                for (int k = 0; k < m; k++) {  //k为1时  k为2时   k表示先要去的城市
                    if(contains(j, k)){   //剩余城市包含出发城市
                        dp[i][j] = Integer.min(dp[i][j], g[i][k] + dp[k][exclude(j, k)]);
                    }
                }
            }
        }
        print(dp);
        return dp[0][n - 1];
    }

这样的数据设计和遍历方式非常nice，表格右边的数据都可以在左边得到。

下面是exclude和contains方法的实现：

/*
        110 是否包含 0 = 0 & 1 = 0
        110 是否包含 1 = 110 & 1 = 0
        110 是否包含 2 = 11 & 1 = 1
        110 是否包含 3 = 1 & 1 = 1
        110 是否包含 4 = 0 & 1 = 0
     */
    static boolean contains(int set, int city) {
        return (set >> (city - 1) & 1) == 1;
    }

    /*
            1|2|3   1 => 2|3        1|2|3  2 => 1|3
            111                     111    异或运算
            001 ^                   010 ^
            ----                   ----
            110                     101

     */
    static int exclude(int set, int city) {
        return set ^ (1 << (city - 1));
    }

---

完整代码：

package dynamicprogramming;

import java.util.Arrays;
import java.util.stream.Collectors;

/**
 * 旅行商问题
 */
public class TravellingSalesmanProblem {

    public static void main(String[] args) {
        int[][] graph = {
                {0, 1, 2, 3},
                {1, 0, 6, 4},
                {2, 6, 0, 5},
                {3, 4, 5, 0},
        };
        System.out.println(tsp(graph));
        //System.out.println(6 >> (0-1));
    }

    static int tsp(int[][] g){
        int m = g.length;  //城市个数
        int n = 1 << (m - 1); //剩余城市的组合数
        int[][] dp = new int[m][n];
        //填充第0列
        for (int k = 0; k < m; k++) {
            dp[k][0] = g[k][0];
        }
        //填充后续列
        for (int j = 1; j < n; j++) {
            for (int i = 0; i < m; i++) {
                dp[i][j] = Integer.MAX_VALUE / 2;  //不要给太大，后面做运算可能会产生整数溢出
                if(contains(j, i)) continue; //剩余城市包含出发城市直接跳过（不合理）
                for (int k = 0; k < m; k++) {  //k为1时  k为2时   k表示先要去的城市
                    if(contains(j, k)){   //剩余城市包含出发城市
                        dp[i][j] = Integer.min(dp[i][j], g[i][k] + dp[k][exclude(j, k)]);
                    }
                }
            }
        }
        print(dp);
        return dp[0][n - 1];
    }

    /*
        110 是否包含 0 = 0 & 1 = 0
        110 是否包含 1 = 110 & 1 = 0
        110 是否包含 2 = 11 & 1 = 1
        110 是否包含 3 = 1 & 1 = 1
        110 是否包含 4 = 0 & 1 = 0
     */
    static boolean contains(int set, int city) {
        return (set >> (city - 1) & 1) == 1;
    }

    /*
            1|2|3   1 => 2|3        1|2|3  2 => 1|3
            111                     111    异或运算
            001 ^                   010 ^
            ----                   ----
            110                     101

     */
    static int exclude(int set, int city) {
        return set ^ (1 << (city - 1));
    }

    static void print(int[][] dist) {
        System.out.println("-------------------------");
        for (int[] row : dist) {
            System.out.println(Arrays.stream(row).boxed()
                    .map(x -> x >= Integer.MAX_VALUE / 2 ? "∞" : String.valueOf(x))
                    .map(s -> String.format("%2s", s))
                    .collect(Collectors.joining(",", "[", "]")));
        }
    }
}