bestcoder Round#52 1001(最短路+状压dp)

求从1点出发，走遍所有的点，然后回到1点的最小代价。

每个点可以走若干遍。

如果每个点只能走一遍，那么设dp[i][s]为走完s状态个点（s是状态压缩），现在位于i的最小花费。

然后枚举从哪个点回到原点即可。

但是现在每个点不止走一次，那么状态就不好表示了，但是，我们可以用floyd处理出任意两点的最短距离。

这样子，可以用上面的方式求解了。

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <algorithm>
#include <iostream>
#include <queue>
#include <stack>
#include <vector>
#include <map>
#include <set>
#include <string>
#include <math.h>
using namespace std;
#pragma warning(disable:4996)
#pragma comment(linker, "/STACK:1024000000,1024000000")
typedef __int64 LL;                   
const int INF = 100000000;
/*



*/
int dp[17][70000];
int dist[20][20];
int g[20][20];
void input(int &x)
{
    char ch = getchar();
    while (ch<'0' || ch>'9')ch = getchar();
    x = 0;
    while (ch >= '0'&&ch <= '9')
    {
        x = x * 10 + ch - '0';
        ch = getchar();
    }
}
int ans;

int main()
{
    //freopen("d:/1.in", "r", stdin);
    int t, n, m, u, v,dis;
    scanf("%d", &t);
    while (t--)
    {
        scanf("%d%d", &n, &m);
        for (int i = 0; i <= n; ++i)
        for (int j = 0; j <= n; ++j)
        {
            g[i][j] = INF;
        }
        for (int i = 0; i < m; ++i)
        {
            input(u);
            input(v);
            input(dis);
            u--;
            v--;
            if (g[u][v]>dis)
                g[u][v] = g[v][u] = dis;
        }
        for (int k = 0; k < n; ++k)
        {
            for (int i = 0; i < n;++i)
            for (int j = 0; j < n; ++j)
                g[i][j] = min(g[i][j],g[i][k]+ g[k][j]);
        }
        
        
        for (int i = 0; i <= n; ++i)
        for (int s = 0; s < (1 << n); ++s)
            dp[i][s] = INF;
        dp[0][1] = 0;
        for (int s = 1; s < (1 << n); ++s)
        {
            for (int i = 0; i < n; ++i)
            {
                if (s&(1 << i))
                {
                    for (int j = 0; j < n; ++j)
                    {
                        if (!(s&(1 << j)))
                        {
                            dp[j][s | (1 << j)] = min(dp[j][s | (1 << j)], dp[i][s] + g[i][j]);
                        }
                    }
                }
            }
        }
        if (n == 1)
        {
            printf("%d
", 0);
            continue;
        }
        int ans = INF;
        for (int i = 1; i < n; ++i)
        {
            ans = min(dp[i][(1 << n) - 1] + g[i][0], ans);
        }
        printf("%d
", ans);
    }
    return 0;
}