POJ-3311（状压dp）

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
/*
题目大意：
给定n + 1个点的图，点与点之间的边权值已知，从点0出发，问经过每个点至少一次后回到点0的最
小花费是多少。

思路：
因为每个点可以经过无数次，所以可以先用Floyd求出所有点两两之间的最短距离。
定义dp[][]，第一维表示当前已经到过的点的集合，1表示到过，0表示没到过；第二维表示当前在哪
个点。因为每个点可以经过无数次，所以dp的时候不需要一定得从到过的点去到没到过的点，可以从
到过的点去到到过的点，这样去状压dp，得到的最终答案就是dp[(1 << (n + 1)) - 1][0]

*/
typedef long long ll;
const int INF = 0x3f3f3f3f;
const double eps = 1e-6;

int G[15][15];
int dp[1 << 15][15];

int main()
{
    int n;
    while(scanf("%d", &n) && n)
    {
        for(int i = 0; i <= n; i++)
        {
            for(int j = 0; j <= n; j++)
            {
                scanf("%d", &G[i][j]);
            }
        }

        memset(dp, 0x3f, sizeof(dp));
        dp[1][0] = 0;
        for(int i = 0; i <= n; i++)
        {
            for(int j = 0; j <= n; j++)
            {
                for(int k = 0; k <= n; k++)
                {
                    G[j][k] = min(G[j][k], G[j][i] + G[i][k]);
                }
            }
        }

        for(int i = 1; i < (1 << (n + 1)); i += 2)
        {
            for(int j = 0; j <= n; j++)
            {
                if(!(i & (1 << j))) continue;
                for(int k = 0; k <= n; k++)
                {
                    dp[i | (1 << k)][k] = min(dp[i | (1 << k)][k], dp[i][j] + G[j][k]);
                }
            }
        }

        printf("%d\n", dp[(1 << (n + 1)) - 1][0]);
    }

    return 0;
}

/*
// 这是第一次通过这道题的代码，应该是POJ的数据比较弱。
// 这道题正常来说这个代码是过不了的，因为我甚至Floyd都没有跑。
// 过得不明不白，还好有做到HDU-5418。

int main()
{
    int n;
    while(scanf("%d", &n) && n)
    {
        for(int i = 0; i <= n; i++)
        {
            for(int j = 0; j <= n; j++)
            {
                scanf("%d", &G[i][j]);
            }
        }
        memset(dp, 0x3f, sizeof(dp));
        dp[1][0] = 0;
        
        for(int i = 1; i < ((1 << (n + 1))); i += 2)
        {
            for(int j = 0; j <= n; j++)
            {   
                for(int k = 0; k <= n; k++)
                {
                    if(!((i >> k) & 1)) continue;
                    dp[i | (1 << j)][j] = min(dp[i | (1 << j)][j], dp[i][k] + G[k][j]);
                }
            }
        }

        int ans = INF;
        for(int i = 1; i <= n; i++)
        {
            ans = min(ans, dp[(1 << (n + 1)) - 1][i] + G[i][0]);
        }
        printf("%d\n", ans);

    }

    return 0;
}
*/