旅行商问题(动态规划思想)
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]);
}
}