【题解】WC2008游览计划

　　写的第一道斯坦纳树的题目。斯坦纳树在信息学中的应用一般为：在\(n\)个点之间给定\(k\)条边并相应的边权，求在保证给定\(m\)个点联通的条件下的最小边权和。解决此类问题的方法即为SPFA + 状压DP。参考论文：姜碧野 《SPFA的优化与应用》

　　我们用\(dp[u][S]\)表示以u为根，联通状态为S（01状态）的最小权值。以u为根：最优解必然构成一棵最小生成树。那么有两种转移方式：

　　\(dp[u][S] = dp[u][k'] + dp[u][k''] - a[u] \left ( S = k' + k'' \right )\)

　　这一个可以理解为\(u\)点为树上的一个分叉点，由该点分别走向两侧，一侧联通\(k'\)集合，一侧联通\(k''\)集合，通过\(u\)点联通成\(S\)集合。这种转移比较好处理，只需枚举子集即可。

　　\(dp[u][S] = dp[v][S] + w[u][v]\)

　　这里是从\(u\)点走向了\(v\)点，联通了这两个集合，通过\(u -> v\)这条边来连接。这一种情况就比较复杂了：\(u\)可以转移到\(v\)，\(v\)也可以转移到\(u\)，但这个方程式却给了我们一点联想：好像很像是最短路中的松弛操作呀。其满足三角形不等式，虽然图中有环的存在，但最优解并不构成环。所以我们用SPFA来进行这一部分的DP。

　　在本题中，\(f[i][j][S]\)代表以点\(i, j\)为根，联通状态为\(S\)的最优权值。

#include <bits/stdc++.h>
using namespace std;
#define maxn 12
#define maxm (1 << 10) + 2
#define INF 1e9
int n, m, K, f[maxn][maxn][maxm];
int a[maxn][maxn], bin[maxn];
int dx[] = {, , , -}, dy[] = {, -, , };
bool vis[maxn][maxn];

struct node
{
    int x, y;
    node (int _x = , int _y = ) { x = _x, y = _y; }
};
queue <node> q;

struct Path
{
    int x, y, s;
    Path (int _x = , int _y = , int _s = ) { x = _x,    y = _y, s = _s; }
}path[maxn][maxn][maxm];

int read()
{
    int x = , k = ;
    char c;
    c = getchar();
    while(c < '' || c > '') { if(c == '-') k = -; c = getchar(); }
    while(c >= '' && c <= '') x = x *  + c - '', c = getchar();
    return x * k;
}

void init()
{
    bin[] = ;
    for(int i = ; i < ; i ++) bin[i] = bin[i - ] << ;
}

void SPFA(int S)
{
    while(!q.empty())
    {
        int x = q.front().x, y = q.front().y;
        vis[x][y] = , q.pop();
        for(int k = ; k < ; k ++)
        {
            int X = x + dx[k], Y = y + dy[k];
            if(X <  || Y <  || X > n || Y > m) continue;
            if(f[X][Y][S] > f[x][y][S] + a[X][Y])
            {
                f[X][Y][S] = f[x][y][S] + a[X][Y];
                path[X][Y][S] = Path(x, y, S);
                if(!vis[X][Y]) q.push(node(X, Y)), vis[X][Y] = ;
            }
        }
    }
}

#define t path[x][y][S]
void dfs(int x, int y, int S)
{
    if(x > INF || !t.s) return;
    vis[x][y] = ; dfs(t.x, t.y, t.s);
    if(t.x == x || t.y == y) dfs(x, y, S ^ t.s);
}
#undef t

void Solve()
{
    for(int S = ; S < bin[K]; SPFA(S ++))
        for(int i = ; i <= n; i ++)
            for(int j = ; j <= m; j ++)
            {
                for(int k = S & (S - ); k; k = (k - ) & S)
                {
                    int t = f[i][j][k] + f[i][j][S ^ k] - a[i][j];
                    if(t < f[i][j][S]) { f[i][j][S] = t; path[i][j][S] = Path(i, j, k); }
                }
                if(f[i][j][S] != INF) { q.push(node(i, j)); vis[i][j] = ; }
            }
}

void Get_ans()
{
    for(int i = ; i <= n; i ++)
        for(int j = ; j <= m; j ++)
            if(!a[i][j])
            {
                dfs(i, j, bin[K] - );
                printf("%d\n", f[i][j][bin[K] - ]);
                return;
            }
}

int main()
{
    init();
    n = read(), m = read();
    for(int i = ; i <= n; i ++)
        for(int j = ; j <= m; j ++)
        {
            a[i][j] = read();
            if(!a[i][j]) K ++;
        }
    for(int i = ; i <= n; i ++)
        for(int j = ; j <= m; j ++)
            for(int k = ; k < bin[K]; k ++)
                f[i][j][k] = path[i][j][k].x = INF;
    K = ;
    for(int i = ; i <= n; i ++)
        for(int j = ; j <= m; j ++)
            if(!a[i][j]) f[i][j][bin[K]] = , K ++;
    Solve();
    memset(vis, , sizeof(vis));
    Get_ans();
    for(int i = ; i <= n; i ++, putchar('\n'))
        for(int j = ; j <= m; j ++)
            if(!a[i][j]) putchar('x');
            else if(vis[i][j]) putchar('o');
            else putchar('_');
    return ;
}