POJ3123：Ticket to Ride（Minimal Steiner Tree）

题目传送门：http://poj.org/problem?id=3123

题目大意是：
给出一个无向图，和四对数据。每对数据分别为图中的两个点。
要求添加一些边，使每对点都能连通，让总边权最小。

首先考虑一个子问题：指定一些点，添加一些边，让它们连通，并且总边权最小。
这个问题就是Minimal Steiner Tree（最小斯坦纳树）问题，什么是Minimal Steiner Tree 见这里。

Minimal Steiner Tree是一个NP问题，但可以转成DP来求解。

动归的转移方程：

dp[mask][i]，其中是以j为根，包含mask中的点的最小生成树的权值。

mask是点的集合，可以用二进制进行状态压缩。

在得知dp[mask - 1][1...N]的情况下，如何推出dp[mask][1...N]呢？

两个步骤实现：

step1推出：

a = min{dp[m1][i] + dp[m2][i]}，其中m1 | m2 = mask。

这个很好理解.....就是两个互补子集.....

在计算子集的时候，可有用for(int sub = mask; sum; sum = (sum - 1) & mask)来枚举子集，我用了这个优化比以前快了将近一倍的速度（果断63MS，杀进POJ第一页）。

step2推出

b = min(dp[mask][j] + d[j][i])

这个更好理解了....就是加上一个边....让i成为了根.....

程序中，每次都从dp[mask][1...N]中选出最小的一个dp[mask][c]，按这种顺序更新就能保证结果的正确

因此dp[mask][i] = min(a, b)

代码：

#include <iostream>
#include <string>
#include <map>

using namespace std;

int main()
{
    int INF = 99999999, N, K, d[30][30], i, j, k, x, y, z;
    int dp[256][30], e[8], v[30], c, b;
    string s, t;
    while (cin >> N >> K && N)
    {
        map <string, int> cityMap;
        for (i = 0; i < N; i++)
            for (j = 0; j < N; j++)
                d[i][j] = i == j ? 0 : INF;
        for (i = 0; i < N; i++)
        {
            cin >> s;
            cityMap[s] = i;
        }
        if (K)
            while (cin >> s >> t >> z, x = cityMap[s],
                    y = cityMap[t],
                    d[x][y] = d[y][x] = min(d[y][x], z), --K);
        for (k = 0; k < N; k++)
            for (i = 0; i < N; i++)
                for (j = 0; j < N; j++)
                    d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
        for (i = 0; i < 8; i++)
        {
            cin >> s;
            e[i] = cityMap[s];
            for (j = 0; j < N; j++)
                dp[1 << i][j] = d[j][e[i]];
        }
        for (i = 1; i < 256; i++)
        {
            if (!(i & (i - 1)))
                continue;
            // step1
            for (k = 0; k < N; k++)
            {
                dp[i][k] = INF;
                v[k] = 0;
                /*for (j = 1; j < i; j++)
                    if ((i | j) == i)
                        dp[i][k] = min(dp[i][k], dp[j][k] + dp[i-j][k]);*/
                for (int sub = i; sub; sub = (sub - 1) & i)
                {
                    dp[i][k] = min(dp[i][k], dp[sub][k] + dp[i - sub][k]);
                }
            }
            // step2
            for (j = 0; b = INF, j < N; j++)
            {
                for (k = 0; k < N; k++)
                    if (dp[i][k] <= b && !v[k])
                        b = dp[i][c = k];
                for (k = 0, v[c] = 1; k < N; k++)
                    dp[i][c] = min(dp[i][c], dp[i][k] + d[k][c]);
            }
        }

        // step3
        for (i = 0, b = INF; z = 0, i < 256; b = min(b, z), i++)
            for (j = 0; y = 0, j < 4; z += !!y * dp[y][x], j++)
                for (k = 0; k < 8; k += 2)
                    if ((i >> k & 3) == j)
                        y += 3 << k, x = e[k];

        cout << b << endl;
    }
    return 0;
}