旅行商问题

旅行商问题（动态规划思想）

1 问题描述

​ 旅行商问题即TSP问题，假设有一个旅行商人要拜访n个城市，他必须选择所要走的路径，路径的限制是每个城市只能拜访一次，而且最后要回到原来出发的城市。路径的选择目标是要求得的路径花费为所有路径之中的最小值。

示例：

输入：
4
0 2 6 5
2 0 4 4
6 4 0 2
5 4 2 0

输出：13，表示走一圈消耗的最小花费。

2 问题分析

​ 由于每个城市都会访问到，因此从哪个城市出发都行，假设从顶点s出发，令dp[i, V]表示从顶点i出发经过点集合V的每一个顶点最后回到出发点s的最短路径长度。转移方程如下：
d p ( i , V ) = { C i s , V = Φ , i ≠ s m i n { C i s + d p ( k , V − { K } ) } , k ∈ V , V ≠ Φ dp(i, V) = \left\{\begin{matrix} Cis, & V=\Phi ,i\neq s\\ min\left \{Cis + dp(k,V-\left \{K\right \})\right \}, & k \in V,V \neq \Phi \end{matrix} \right. dp(i,V)={Cis,min{Cis+dp(k,V−{K})},​V=Φ,i​=sk∈V,V​=Φ​
其中s为起点，Cis表示选择城市i与城市s的距离。

对矩阵从0开始编号，我们要求的最终结果为dp[0, {1,2,3}],表示从城市0开始，经过{1,2,3}之中的城市并且只有一次的最短路径。用数组dp[N] [M]来进行存储，N表示城市的数量，M表示集合的数量（∅，{1}，{2}，{3}，{1,2},{1,3},{2,3},{1,2,3}）M=2^N-1。如下表：我们这里始终要记得j并不仅仅是索引，它的二进制更是一个集合，表示存在哪些城市。（PS：真的是妙啊！）

注意，代码中会有部分位运算，这里提前解释一下：

1 << (N - 1) —> 同2^N-1，为dp数组的列长度，因为N个城市，会有2 ^N-1个子集合状态，参照上表

(j >> (i - 1) & 1)) == 1 --> 首先要知道j的二进制还代表该集合中存在哪些城市，比如j = 3 也就是010,表示该集合中有第二个城市，那么j >> (i - 1)最右边的就代表着是否存在第i个城市，与1取且，如果值为1表示存在，否则表示集合j中不存在i城市。

j ^ (1 << (k - 1)) —>同样可以表示从集合j中剔除第k个城市，因为1左移k-1位就相当于第k个位置为1与j取异或，如果j中也有第k个则该位置变为0，即剔除掉。

3 代码

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        // 城市数量
        int N = sc.nextInt();
        // 城市之间的距离矩阵
        int[][] dist = new int[N][N];
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                dist[i][j] = sc.nextInt();
            }
        }
        int M = 1 << (N - 1);  // 2^n-1
        // 创建dp表
        int[][] dp = new int[N][M];
        // 初始化
        for (int i = 0; i < N; i++) {
            dp[i][0] = dist[i][0];
        }
        // 求解dp数组其他值：注意dp数组的j不仅仅是坐标，其二进制还代表包含着哪些城市节点。
        // 如：j = 2的二进制010表示该集合V包含第二个城市，判断横坐标第j个集合是否包含节点i可以用j >> (i - 1) & 1是否为1来确定。
        for (int j = 1; j < M; j++) {
            for (int i = 0; i < N; i++) {
                // 初始化dp[i][j] = INF
                dp[i][j] = Integer.MAX_VALUE;
                if ((j >> (i - 1) & 1) == 1) {  // j集合状态中包含i城市，不能以i城市为起点，结束当前循环
                    continue;
                }
                // 从集合中依次剔除从1开始的城市，更新dp
                for (int k = 1; k < N; k++) {
                    if ((j >> (k - 1) & 1) == 0) {
                       // 如果集合中不存在k则退出本次循环
                       continue;
                    }
                    // 转移方程，更新dp,dp[k][j ^ (1 << (k - 1))])中的列元素表示剔除j集合的k城市
                    dp[i][j] = Math.min(dp[i][j], dist[i][k] + dp[k][j ^ (1 << (k - 1))]);
                }
            }
        }
        // dp[0][M - 1]为最短花费
        System.out.println(dp[0][M - 1]);
    }
}