[BZOJ]2595 [WC2008] 游览计划 斯坦纳树

2595: [Wc2008]游览计划

Time Limit: 10 Sec   Memory Limit: 256 MBSec   Special Judge
Submit: 1862   Solved: 905
[ Submit][ Status][ Discuss]

Description

Input

第一行有两个整数，N和 M，描述方块的数目。 
接下来 N行， 每行有 M 个非负整数， 如果该整数为 0， 则该方块为一个景点；
否则表示控制该方块至少需要的志愿者数目。 相邻的整数用 （若干个） 空格隔开，
行首行末也可能有多余的空格。

Output

由 N + 1行组成。第一行为一个整数，表示你所给出的方案
中安排的志愿者总数目。 
接下来 N行，每行M 个字符，描述方案中相应方块的情况： 
z  ‘_’（下划线）表示该方块没有安排志愿者； 
z  ‘o’（小写英文字母o）表示该方块安排了志愿者； 
z  ‘x’（小写英文字母x）表示该方块是一个景点； 
注：请注意输出格式要求，如果缺少某一行或者某一行的字符数目和要求不
一致（任何一行中，多余的空格都不允许出现） ，都可能导致该测试点不得分。

Sample Input

4 4
0 1 1 0
2 5 5 1
1 5 5 1
0 1 1 0

Sample Output

6
xoox
___o
___o
xoox

HINT

 对于100%的数据，N,M,K≤10，其中K为景点的数目。输入的所有整数均在[0,2^16]的范围内

Source

Ljcc930提供SPJ

[ Submit][ Status][ Discuss] 

HOME Back

　　一直以为斯坦纳树是数据结构... 于是去学了一发， 发现是跟最小生成树有点像的东西. 斯坦纳树就是来解决将多个钦定的关键点连接成树的问题. 而如果有点权(边权)， 一般是求最小(大)斯坦纳树(权值和最小/大). 譬如这道题就是求最小斯坦纳树. 这类问题实际上是NPC问题... 不过在数据范围较小的情况下可以用状压搞搞解决.

　　实际上斯坦纳树是用了dp. 拿这道题来举例， 我们设f[i][j][s]为以(i, j)这个点为根此时连通性为s的最小权值和. 那么考虑如何转移.

　　首先可以由子集转移过来. f[i][j][sta] = min(f[i][j][sta], f[i][j][s] + f[i][j][sta ^ s] - a[i][j])(-a[i][j]是因为重算了根). 对于子集枚举技巧可见代码.

　　其次显然某棵树可以由某棵树加边而来. f[i][j][sta] =min(f[i][j][sta], f[x][y][sta] + a[i][j]). 我们会发现这个很像三角形不等式， 于是spfa即可. 这里只对当前状态进行松弛. 因为其他的联通状态都可由上一层子集转移来更新. 所以只用对当前进行spfa辣.

　　通过以上两种转移就可以搞出斯坦纳树了， excited! 记录方案就非常的naive了. 总的来说十分好写. 第一次写斯坦纳树就从黄学长那里借(fang)鉴(chao)了一下. 发现仿抄速度快过香港记者

　　Ps: 自作聪明的还搞了个寻址优化才发现自己根本不懂什么叫寻址优化啊... 改天好好学一发卡常.

#include<bits/stdc++.h>
#define xx first
#define yy second
#define mp make_pair
#define fufil(a) memset(a, 0x3f, sizeof(a))
using namespace std;
const int inf = 1e9;
const int maxn = 12;
const int maxm = (1 << 10) + 5;
bool ans[maxn][maxn], vis[maxn][maxn];
int n, m, k, stx, sty, a[maxn][maxn], f[maxn][maxn][maxm];
struct rd {
    int x, y, sta;
    rd(){}
    rd(int a, int b, int c) : x(a), y(b), sta(c) {}
}pr[maxn][maxn][maxm];
queue<pair<int, int> > q;
int dx[4] = {1, -1, 0, 0}, dy[4] = {0, 0, 1, -1};
inline void spfa(int s) {
    while (!q.empty()) {
        int x = q.front().xx, y = q.front().yy;
        vis[x][y] = false, q.pop();
        for (int k = 0; k < 4; ++ k) {
            int nx = x + dx[k], ny = y + dy[k];
            if (nx < 1 || nx > n || ny < 1 || ny > m) continue;
            if (f[nx][ny][s] > f[x][y][s] + a[nx][ny]) {
                f[nx][ny][s] = f[x][y][s] + a[nx][ny];
                pr[nx][ny][s] = rd(x, y, s);
                if (!vis[nx][ny]) vis[nx][ny] = true, q.push(mp(nx, ny));
            }
        }
    }
}
void dfs(int x, int y, int sta) {
    ans[x][y] = true;
    rd t = pr[x][y][sta];
    if (!t.x && !t.y) return;
    dfs(t.x, t.y, t.sta);
    if (t.x == x && t.y == y) dfs(t.x, t.y, sta ^ t.sta);
}
int main() {
    fufil(f);
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; ++ i)
        for (int j = 1; j <= m; ++ j) {
            scanf("%d", &a[i][j]);
            if (!a[i][j]) f[i][j][1 << k] = 0, k ++, stx = i, sty = j;
        }
    int lim = 1 << k;
    for (int sta = 0; sta < lim; ++ sta) {
        for (int i = 1; i <= n; ++ i)
            for (int j = 1; j <= m; ++ j) {
                for (int s = sta & (sta - 1); s; s = sta & (s - 1)) {
                    int nw = f[i][j][s] + f[i][j][sta ^ s] - a[i][j];
                    if (nw < f[i][j][sta]) {
                        f[i][j][sta] = nw;
                        pr[i][j][sta] = rd(i, j, s);
                    }
                }
                if (f[i][j][sta] < inf) q.push(mp(i, j)), vis[i][j] = true;
            }
        spfa(sta);
    }
    printf("%d\n", f[stx][sty][lim - 1]);
    dfs(stx, sty, lim - 1);
    for (int i = 1; i <= n; ++ i, puts(""))
        for (int j = 1; j <= m; ++ j) {
            if (!a[i][j]) putchar('x');
            else if (ans[i][j]) putchar('o');
            else putchar('_');
        }
    return 0;
}