WC2008 游览计划 斯坦纳树

题目链接：http://wikioi.com/problem/1241/

参考资料：《SPFA算法的优化与应用》

论文题，不过最开始看论文的时候没看懂，碰到上篇博客中的那题索性就一起解决了。

根据题意猜测答案是一颗树，然后就是状态压缩构造树的过程。

应为要输出解，建议先把上面那题弄懂再写这题，不然不知道怎么记录解。

还是这两个状态转移：

枚举子树的形态：dp[ i ][ j ]=min{ dp[ i ][ j ]，dp[ i ][ k ]+dp[ i ][ l ] }，其中k和l是对j的一个划分。

按照边进行松弛：dp[ i ][ j ]=min{ dp[ i ][ j ]，dp[ i' ][ j ]+w[ i ][ i' ] }，其中i和i'之间有边相连。

第二个状态转移中，每个状态的pre是唯一的。

不好记录的是第一个状态转移。

但是在这种状态转移中，当前的x y 和前驱状态的x y 是相同的，

而且知道一个前驱状态，另一个前驱状态就能知道了，以此来记录状态。

然后记录路径就好了。

（输出时候把减号当成下划线。。。坑了好久。。。）

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cstdlib>
#include <queue>
#include <stack>
#include <set>
#include <map>
using namespace std;
#define REP(i,n)   for(int i=0;i<(n);++i)
#define FOR(i,l,r) for(int i=(l);i<=(r);++i)
#define DSC(i,r,l) for(int i=(r);i>=(l);--i)
#define N 10
#define NN (1<<10)
#define INF 1e9
#define get(x,y,s) ( (x)*100000 + (y)*10000 + (s) )
int dx[]={0,1,0,-1},
    dy[]={1,0,-1,0};
bool flag[N][N];
int n,m,nn,num;
int g[N][N];
int dp[N][N][NN];
bool visit[N][N][NN];
int pre[N][N][NN];
int pos[N][N];

queue<int>q;
void init()
{
    REP(i,n)
        REP(j,m)
            REP(k,nn)
                dp[i][j][k]=INF;
    REP(i,n)
        REP(j,m)
            if(pos[i][j])  dp[i][j][ pos[i][j] ]=0;
}

void spfa()//第二种状态转移并记录前驱状态
{
    while(!q.empty())
    {
        int temp=q.front(); q.pop();
        int x=temp/100000,y=(temp%100000)/10000,s=temp%10000;
        visit[x][y][s]=0;

        REP(k,4)
        {
            int tx=x+dx[k],ty=y+dy[k];
            if(tx<0 || tx==n || ty<0 || ty==m) continue;
            int ts=s|pos[tx][ty];
            temp=dp[x][y][s]+g[tx][ty];

            if(temp<dp[tx][ty][ts])
            {
                dp[tx][ty][ts]=temp;
                pre[tx][ty][ts]=get(x,y,s);
                if(ts==s && !visit[tx][ty][ts])
                {
                    visit[tx][ty][ts]=1;
                    q.push(get(tx,ty,ts));
                }
            }
        }
    }
}

void solve()
{
    REP(s,nn)
    {
        REP(x,n)
            REP(y,m)
            {
                if(pos[x][y] && !(pos[x][y]&s)) continue;//这句必须加, 不然把两个状态|pos[x][y]就不合法了
                for(int i=s&(s-1);i;i=s&(i-1))//第一种状态转移
                {   //一个前驱状态为 (i|pos[x][y])  的话,另一个子状态为 ((s-i)|pos[x][y])
                    int temp=dp[x][y][ i|pos[x][y] ] + dp[x][y][ (s-i)|pos[x][y] ] - g[x][y];
                    if(temp<dp[x][y][s])
                    {
                        dp[x][y][s]=temp;
                        pre[x][y][s]=get(x,y,i|pos[x][y]);
                    }
                }
                if(dp[x][y][s]<INF)
                {
                    q.push( get(x,y,s) );
                    visit[x][y][s]=1;
                }
            }
        spfa();
    }
}

void dfs(int x,int y,int s)
{
    flag[x][y]=1;
    int temp=pre[x][y][s];
    if(temp==-1) return ;
    int prex=temp/100000,prey=(temp%100000)/10000,pres=temp%10000;
    dfs(prex,prey,pres);

    //如果x==prex&&y==prey，说明是由第一个状态转移得到的
    //并且,如果知道了其中一个子状态，另一个子状态是唯一的
    if(prex==x && prey==y)
    {
        dfs(x,y, (s-pres) | pos[x][y] );
    }
}

void out()
{
    REP(i,n)
        REP(j,m)
            if(!g[i][j])
            {
                dfs(i,j,nn-1);
                cout<<dp[i][j][ nn-1 ]<<endl;
                return ;
            }
}

int main()
{
    while(cin>>n>>m)
    {
        memset(pos,0,sizeof(pos));
        memset(visit,0,sizeof(visit));
        memset(pre,-1,sizeof(pre));
        memset(g,0,sizeof(g));
        memset(flag,0,sizeof(flag));

        num=0;
        REP(i,n)
            REP(j,m)
            {
                scanf("%d",&g[i][j]);
                if(!g[i][j])    pos[i][j]=(1<<num++);
            }

        nn=(1<<num);
        init();
        solve();
        out();

        REP(i,n)
        {
            REP(j,m)
            {
                if(!g[i][j]) putchar('x');
                else
                {
                    if(flag[i][j]) putchar('o');
                    else putchar('_');
                }
            }
            puts("");
        }
    }
    return 0;
}