AcWing 91. 最短Hamilton路径

\(AcWing\) \(91\). 最短\(Hamilton\)路径

一、题目描述

给定一张 \(n\) 个点的 带权无向图，点从 \(0∼n−1\) 标号，求起点 \(0\) 到终点 \(n−1\) 的最短 \(Hamilton\) 路径。

\(Hamilton\) 路径的定义是从 \(0\) 到 \(n−1\) 不重不漏地经过每个点恰好一次。

输入格式
第一行输入整数 \(n\)。

接下来 \(n\) 行每行 \(n\) 个整数，其中第 \(i\) 行第 \(j\) 个整数表示点 \(i\) 到 \(j\) 的距离（记为 \(a[i,j]\)）。

对于任意的 \(x,y,z\)，数据保证 \(a[x,x]=0，a[x,y]=a[y,x]\), 并且 \(a[x,y]+a[y,z]≥a[x,z]\)。

输出格式
输出一个整数，表示最短 \(Hamilton\) 路径的长度。

数据范围
\(1≤n≤20\)

\(0≤a[i,j]≤10^7\)

输入样例：

5
0 2 4 5 1
2 0 6 5 3
4 6 0 8 3
5 5 8 0 5
1 3 3 5 0

输出样例：

18

二、暴力穷举为什么不行

暴力来做的话，需要确定走的顺序，是一个\(0\)到\(n-1\)的全排列 ，假设\(n=5\) .就是\(0\)号到\(4\)号，共\(5\)个节点。

\(0\ 1\ 2\ 3\ 4\)
\(0\ 1\ 3\ 2\ 4\)
\(0\ 2\ 1\ 3\ 4\)
\(0\ 2\ 3\ 1\ 4\)
\(0\ 3\ 1\ 2\ 4\)
\(0\ 3\ 2\ 1\ 4\)

共\(6\)组，个数是\((n-2)!\)个，（因为首尾是固定的，其它的是全排列）

如果要暴力解决，那么每一组解都需要遍历一次所有节点的权，就是需要一重循环加上去，是\(n\)个，就是\(n * (n-2)!\)个。\(n\)要是\(20\)左右的数，就很恐怖了。

三、动态规划为什么行?

动态规划从本质上讲，并没有真正算出所有的可行解是什么，而一般是计算 最大值，最小值，总方案数 等，说白了，就是只计算数量，而不是真的列出来到底是哪些，举个栗子,老师让孩子数一下\(1\)到\(100\)有多少个数，有的孩子是掰手指头一个个查，最终答案是\(100\),有的孩子聪明，知道\(1\)到\(100\)是\(100\)个数是一个道理。

四、为什么要用状态压缩?

举个栗子：
当有三个布尔类型变量 \(a、b、c\) 时，它们的取值只能为 \(true\) 或 \(false\)。如果要枚举所有可能的取值情况，可以写出如下的代码：

for (bool a = false; a <= true; a++) {
    for (bool b = false; b <= true; b++) {
        for (bool c = false; c <= true; c++) {
            // 枚举所有情况，进行操作
        }
    }
}

这样的代码嵌套了三层循环，代码看起来十分冗长，而且还不够灵活，如果有更多的变量，循环嵌套的层数将会更多。使用状态压缩，可以将所有变量的取值状态压缩到一个整数中，用循环遍历这个整数即可，代码会变得更加简洁和灵活。

对于上面的例子，可以使用 \(3\) 个二进制位来表示变量的取值情况，用 \(1\) 表示 \(true\)，\(0\) 表示 \(false\)，共有 \(2^3=8\) 种取值情况，分别对应 \(000、001、010、011、100、101、110、111\) 这 \(8\) 个二进制数。使用一个整数来存储这 \(3\) 个变量的取值情况，可以写出如下的代码：

for (int i = 0; i < 8; i++) {
    bool a = i & 1;
    bool b = i & 2;
    bool c = i & 4;
    // 对 a、b、c 进行操作
}

在这个例子中，使用了一个整数来存储 \(a、b、c\) 三个变量的取值情况，即将三个二进制位拼接成一个整数。通过循环遍历 \(0\) 到 \(7\) 的整数，将其转化为二进制表示，就可以得到所有的取值情况，然后再将这个整数转化回 \(a、b、c\) 三个变量的取值，进行操作。

如果使用二进制描述的话，那么 左移，右移，与，或，非，异或 等操作就是非常自然的，可以很灵活找出两个状态之间的 交集，并集 等，非常方便。

五、状态压缩\(DP\)分析

1.本题思路

假设:一共有七个点,用\(0,1,2,3,4,5,6\)来表示,那么先假设终点就是\(5\),在这里我们再假设还没有走到\(5\)这个点,且走到的终点是\(4\),那么有以下六种情况:

• \(first\) : \(0–>1–>2–>3–>4\) 距离:\(21\)
• \(second\) : \(0–>1–>3–>2–>4\) 距离:\(23\)
• \(third\) : \(0–>2–>1–>3–>4\) 距离:\(17\)
• \(fourth\) : \(0–>2–>3–>1–>4\) 距离:\(20\)
• \(fifth\) : \(0–>3–>1–>2–>4\) 距离:\(15\)
• \(sixth\) : \(0–>3–>2–>1–>4\) 距离:\(18\)

如果此时你是一个商人你会走怎样的路径?显而易见,会走第五种情况对吧?因为每段路程的终点都是\(4\),且每种方案的可供选择的点是\(0 \sim 4\),而商人寻求的是走到\(5\)这个点的最短距离,而\(4\)到\(5\)的走法只有一种,所以我们选择第五种方案，可寻找到走到\(5\)这个点儿之前,且终点是\(4\)的方案的最短距离,此时\(0\)~\(5\)的最短距离为(\(15+4\)走到\(5\)的距离).(假设\(4–>5=8\))

同理:假设还没有走到\(5\)这个点儿,且走到的终点是\(3\),那么有一下六种情况:
\(first\): \(0–>1–>2–>4–>3\) 距离:\(27\)
\(second\): \(0–>1–>4–>2–>3\) 距离:\(22\)
\(third\): \(0–>2–>1–>4–>3\) 距离:\(19\)
\(fourth\): \(0–>2–>4–>1–>3\) 距离:\(24\)
\(fifth\): \(0–>4–>1–>2–>3\) 距离:\(26\)
\(sixth\): \(0–>4–>2–>1–>3\) 距离:\(17\)

此时我们可以果断的做出决定:走第六种方案!!!,而此时\(0\)~\(5\)的最短距离为(\(17+3\)走到\(5\)的距离)(假设\(3–>5=5\))

在以上两大类情况之后我们可以得出当走到\(5\)时:
1.以\(4\)为终点的情况的最短距离是:\(15+8=23\);
2.以\(3\)为终点的情况的最短距离是:\(17+5=22\);

经过深思熟虑之后,商人决定走以\(3\)为终点的最短距离,此时更新最短距离为:\(22\)。

当然以此类推还会有以\(1\)为终点和以\(2\)为终点的情况,此时我们可以进行以上操作不断更新到\(5\)这个点的最短距离,最终可以得到走到\(5\)这个点儿的最短距离,然后再返回最初的假设,再依次假设\(1,2,3,4\)是终点,最后再不断更新,最终可以得出我们想要的答案。

2、\(DP\)分析

用二进制来表示要走的所有情况的路径,这里用\(i\)来代替
例如走\(0,1,2,4\)这三个点,则表示为:\(10111\); (从右向左读)
走\(0,2,3\)这三个点:\(1101\);

状态表示:
\(f[i][j]\)

集合
所有从\(0\)走到\(j\),走过的所有点的情况是\(i\)的所有路径

属性:
\(min\)

状态计算
如\(1\)中分析一致,\(0–>·····–>k–>j\)中\(k\)的所有情况

状态转移方程

\[\large f[i][j]=min(f[i][j],f[i-(1<<j)][k]+w[k][j]) \]

六、实现代码

#include <bits/stdc++.h>

using namespace std;
const int N = 20;     // 好小的上限N,大的没法状态压缩实现,2^N不能太大啊！
const int M = 1 << N; // 2的N次方
int w[N][N];          // 邻接矩阵，记录每两个点之间的距离
int f[M][N];          // DP状态数组,记录每一步的最优解
int n;                // n个结点

int main() {
    cin >> n;
    // 邻接矩阵
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            cin >> w[i][j];

    // 求最短，设最大
    memset(f, 0x3f, sizeof f);

    // ① 初始化,从0出发到0结束，路线状态表示为1
    f[1][0] = 0; // 从0走到0,路线为1，也就是二进制表示法为(1)_2,表示0出现过

    for (int i = 0; i < (1 << n); i++)      // 枚举所有路线
        for (int j = 0; j < n; j++)         // 枚举每个节点作为阶段性终点
            if (i >> j & 1) {               // 这个节点是不是包含在路径中
                for (int k = 0; k < n; k++) // 引入结点k,使得距离更短
                    // 需要满足i这个路径中除去j这个点，一定要包含k这个点
                    if ((i - (1 << j)) >> k & 1)
                        f[i][j] = min(f[i][j], f[i - (1 << j)][k] + w[k][j]);
            }

    // 最终经历了所有结点，并且最后停在n-1(最后一个点，因为坐标从0开始)这个点
    cout << f[(1 << n) - 1][n - 1] << endl;
    return 0;
}