AtCoder Beginner Contest 338F - Negative Traveling Salesman【floyd+状态压缩dp】

原题链接：https://atcoder.jp/contests/abc338/tasks/abc338_f

Time Limit: 6 sec / Memory Limit: 1024 MB

Score: 500 points、

问题陈述

有一个有N个顶点和M条边的加权简单有向图。顶点的编号为 1 到 N，i/th 边的权重为 Wi​，从顶点 Ui​ 延伸到顶点Vi​。权重可以为负，但该图不包含负循环。

确定是否存在至少访问每个顶点一次的行走。如果存在这样的行走，请找出所遍历的边的最小总权重。如果同一条边被多次遍历，则每次遍历都要加上这条边的权重。

这里的 "至少访问每个顶点一次的行走 "是指满足以下两个条件的顶点序列v1​,v2​,…,vk​：

• 对于每个 i 有一条边从顶点 vi​ 延伸到顶点 vi+1​。
• 对于每个 j (1≤j≤N) 都有 i (1≤i≤k) 这样的边 vi​=j 。

限制因素

• 2≤N≤20
• 1≤M≤N(N−1)
• 1≤Ui​,Vi​≤N
• Ui​Vi​
• (Ui​,Vi​)(Uj​,Vj​)
• −1e6≤Wi​≤1e6
• 给定图形不包含负循环。
• 所有输入值均为整数。

输入输出描述

Sample Input 1Copy

3 4
1 2 5
2 1 -3
2 3 -4
3 1 100

Sample Output 1Copy

-2

按照 2→1→2→3 的顺序跟随顶点，可以访问所有顶点至少一次，所遍历的边的总重量为 (−3)+5+(−4)=−2。这是最小值。

Sample Input 2Copy

3 2
1 2 0
2 1 0

Sample Output 2Copy

No

没有至少访问所有顶点一次的行走。

Sample Input 3Copy

5 9
1 2 -246288
4 5 -222742
3 1 246288
3 4 947824
5 2 -178721
4 3 -947824
5 4 756570
2 5 707902
5 1 36781

Sample Output 3Copy

-449429

解题思路：

首先题目要求我们至少经过每个点一次，也就是说我们只要找到一条路径经过了每个点并且这条路径权值总和最小，也就是说我们并不关心每个点经过了几次，只要经过了就行了，例如如果我们找到了一条权值总和最小并且经过所有点至少一次的路径a->b->c->b->d,我们考虑的路径集合应该是a->b->c->d,，也就是说c->b->d中间的b只是c->d最短路径经过的一个点而已，也就是说我们只需要考虑走过每个点的顺序即可，确定了顺序之后，任意俩个点之间的距离应该使用最短路径，由于不存在负环，任意俩个点之间肯定是存在最短路径的，并且最短路径的长度肯定是确定的，这个题目点的个数最多只有20个，对于考虑哪种走的顺序总路径最短，我们可以考虑状态压缩dp,然后需要提前预处理任意俩个点之间的最短路，可以采用floyd算法才求任意俩点之间的最短路径，预处理之后状态压缩dp处理即可，具体分析见代码处。

状态压缩dp处理过程

状态定义：

定义f[i][j]表示当前走的点的集合为i,并且走过的最后一个点为j的所有方案的最短路径。

初始化：

f[1<<i][i]=0,当前集合只有一个点，就是起点。

状态转移：

当前走过的最后一个点是j，需要考虑倒数第二个点k,用来转移

f[i][j]=min(f[i^(1<<j][k]+d[k][j])

最终答案：

最终走过的点的集合肯定是(1<<n)-1，然后走过的最后一个点可以是任意一个点，所以答案就是min(f[(1<<n)-1][i]) (0<i<n)

时间复杂度：floyd预处理时间复杂度为O(n^3)，n=20,这个时间大概是8e3，状态压缩dp处理时间复杂度为O((2^n)*n*n)，这个时间大概为4e8，这个时间复杂度很高了，但是这个题目给了6s的时间，所以是可以过的，最终是时间复杂度为O((n^3)+(2^n)*n*n)。

空间复杂度：d数组空间为O(n^2)，dp数组f空间为O((2^n)*n),最终空间复杂度为O((n^2)+(2^n)*n),空间大概是(20^2+(2^20)*20)，大概是2e7*4/1e6=80M,这个题目给了1024M，空间肯定是足够的。

cpp代码如下：

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 25, M = 1 << 20, INF = 0x3f3f3f3f;

int n, m;
int d[N][N], f[M][N];

void floyd()
{
    for (int k = 0; k < n; k++)
        for (int i = 0; i < n; i++)
            for (int j = 0; j < n; j++)
            {
                if (d[i][k] == INF || d[k][j] == INF)
                    continue;
                d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
            }
}
int main()
{
    cin >> n >> m;
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            if (i == j)
                d[i][j] = 0;
            else
                d[i][j] = INF;
    for (int i = 0; i < m; i++)
    {
        int u, v, w;
        scanf("%d%d%d", &u, &v, &w);
        u--, v--;
        d[u][v] = w;    //题目说了不存在重边。所以这里可以直接赋值，如果存在重边应该取所有重边的最小值
    }

    //floyd预处理任意俩个点之间的最短路
    floyd();
    memset(f, 0x3f, sizeof f);
    //初始之起点
    for (int i = 0; i < n; i++)
        f[1 << i][i] = 0;
    //状态压缩dp处理过程
    for (int i = 0; i < 1 << n; i++)  //第一维枚举走过的点的集合
        for (int j = 0; j < n; j++)   //第二维枚举当前走的点的集合中的最后一个点
        {
            if (~i >> j & 1)    //当前最后一个点是j,那么当前走过的点的集合必须包含j,
                continue;
            for (int k = 0; k < n; k++)
            {
                if (j == k)   //不可能自己走到自己
                    continue;
                if (~i >> k & 1) //前一个点是k,所以当前走过的点的集合i中必须包含k
                    continue;
                if (f[i ^ (1 << j)][k] == INF || d[k][j] == INF)  //INF表示某种状态不存在或者俩个点之间不存在边，不能用于转移
                    continue;
                f[i][j] = min(f[i][j], f[i ^ (1 << j)][k] + d[k][j]);
            }
        }

    int ans = INF;
    //当前走过的点的集合肯定是(1<<n)-1，最后一个点可以是任意一个点
    for (int i = 0; i < n; i++)
        ans = min(ans, f[(1 << n) - 1][i]);
    if (ans == INF)   //不存在走过每个点至少一次的路径，输出No
        puts("No");
    else         //存在走过每个点至少一次的路径，输出最短路径的长度
        cout << ans << endl;
    return 0;
}