【BZOJ2595】游览计划（状压DP，斯坦纳树）

题意：见题面（我发现自己真是越来越懒了）

有N*M的矩阵，每个格子有一个值a[i,j]

现要求将其中的K个点（称为关键点）用格子连接起来，取(i,j)的费用就是a[i,j]

求K点全部连通的最小花费以及方案

n,m,k<=10

思路：斯坦纳树

虽然去年就疑似过了一道裸题，不过估计也是COPY的std，早就忘干净了

先%了一发论文，看到了几道有意思的SPFA的应用，准备去做一下

dp[i,j,sta]表示以(i,j)为根，关键点联通情况为sta的最小花费

显然初始化 [ dp[i,j,1<<(k-1)]=0 （i,j为k号关键点）]

[ dp[i,j,sta]=dp[i,j,x]+dp[i,j,sta xor x]-a[i,j] ] 即合并子集

[ dp[i,j,sta]=dp[x,y,sta]+a[i,j]]  即合并道路

第一个转移可以枚举子集

第二个转移可能有环且形式是最短路，使用SPFA队列更新

类似一个分层图，SPFA的时候只用跑本层的内容

以下转自某大神blog：进行spfa的时候只需要对当前层的节点进行spfa就行了，不需要整个图完全松弛一遍，因为更高的层都可以通过枚举子集而变成若干个更低的层

时间复杂度：SPFA显然O(2^k)

枚举子集的dp时每个点有3个状态：不是子集，是子集但没取到，是子集且枚举到了

所以O(3^k)

总时间复杂度O(3^k*n*m)

PS：其实暴力的想法：Sigma C(k,k-i)*2^i用二项式展开就是3^k啦（感谢邻桌数学国家队CWY同学）

const oo=2000000000;
      dx:array[1..4]of longint=(-1,1,0,0);
      dy:array[1..4]of longint=(0,0,-1,1);
var dp:array[1..12,1..12,0..1100]of longint;
    pre:array[1..12,1..12,0..1100,1..3]of longint;
    flag,a,inq:array[1..12,1..12]of longint;
    q:array[0..2000,1..3]of longint;
    n,m,i,j,x,y,k,v,k1,t,w,sta,tmp,ux,uy:longint;

procedure dfs(i,j,sta:longint);
var x,y,z:longint;
begin
 if sta=0 then exit;
 flag[i,j]:=1;
 x:=pre[i,j,sta,1]; y:=pre[i,j,sta,2]; z:=pre[i,j,sta,3];
 dfs(x,y,z);
 if (x=i)and(y=j) then dfs(x,y,sta xor z);
end;

procedure print(x,y:longint);
var i,j:longint;
begin
 writeln(dp[x,y,(1<<k1)-1]);
 fillchar(flag,sizeof(flag),0);
 dfs(x,y,(1<<k1)-1);
 for i:=1 to n do
 begin
  for j:=1 to m do
   if a[i,j]>0 then
   begin
    if flag[i,j]=1 then write('o')
     else write('_');
   end
    else write('x');
  writeln;
 end;
end;

begin
 assign(input,'bzoj2595.in'); reset(input);
 assign(output,'bzoj2595.out'); rewrite(output);
 readln(n,m);
 for i:=1 to n do
  for j:=1 to m do read(a[i,j]);
 fillchar(dp,sizeof(dp),$7f);
 for i:=1 to n do
  for j:=1 to m do
   if a[i,j]=0 then
   begin
    inc(k1); dp[i,j,1<<(k1-1)]:=0;
   end;
 for v:=1 to (1<<k1)-1 do
 begin
  fillchar(inq,sizeof(inq),0);
  t:=0; w:=0;
  for i:=1 to n do
   for j:=1 to m do
   begin
    x:=v and (v-1);
    while x>0 do
    begin
     tmp:=dp[i,j,x]+dp[i,j,v xor x]-a[i,j];
     if tmp<dp[i,j,v] then
     begin
      dp[i,j,v]:=tmp;
      pre[i,j,v,1]:=i; pre[i,j,v,2]:=j; pre[i,j,v,3]:=x;
     end;
     x:=v and (x-1);
    end;
    if dp[i,j,v]<oo then begin inc(w); q[w,1]:=i; q[w,2]:=j; inq[i,j]:=1; end;
   end;
   while t<w do
   begin
    inc(t); ux:=q[t mod 2000,1]; uy:=q[t mod 2000,2]; inq[ux,uy]:=0;
    for k:=1 to 4 do
    begin
     x:=ux+dx[k]; y:=uy+dy[k];
     if (x>0)and(x<=n)and(y>0)and(y<=m)and(dp[ux,uy,v]+a[x,y]<dp[x,y,v]) then
     begin
      dp[x,y,v]:=dp[ux,uy,v]+a[x,y];
      pre[x,y,v,1]:=ux; pre[x,y,v,2]:=uy; pre[x,y,v,3]:=v;
      if inq[x,y]=0 then
      begin
       inc(w); q[w mod 2000,1]:=x; q[w mod 2000,2]:=y; inq[x,y]:=1;
      end;
     end;
    end;
   end;
 end;



 for i:=1 to n do
 begin
  for j:=1 to m do
   if a[i,j]=0 then begin print(i,j); break; end;
  if a[i,j]=0 then break;
 end;
 close(input);
 close(output);
end.