【HDOJ5713】K个联通块（状压DP，计数）

题意：有一张无重边的无向图， 求有多少个边集，使得删掉边集里的边后，图里恰好有K个连通块。 

1≤T≤20
1≤K≤N≤14
0≤M≤N∗(N+1)/2
1≤a,b≤N

思路：From http://blog.csdn.net/di4covery/article/details/51699544

一个简单的结论：删除边集的个数 = 选择边集的个数 ， 这样我们就可以把问题转化为选取若干条边使得图里面恰好有K个联通块。

问题可以转化成三个状态压缩DP来完成（这三个DP都不难）

1、num[ mask ] 表示选取mask状态的点两两连边的边数。（这是一个很小的数）

这个数组我们通过状态压缩DP来求

令 u = lowbit (mask)  （即mask状态中编号最小的那个点）

枚举mask中的点v，计算边u,v的个数tmp

num [ mask ] = num [ mask ^u ] + tmp;

2、f [ mask ] 表示选取mask状态的点 ，构成一个联通块 的方案数

同样，利用上一次求出来的num数组，状态压缩DP来求

容斥原理 ： 合法方案数 = 总方案数 - 不合法方案数

总方案数 ：  2 ^ num( mask ) （每条边选或者不选）

不合法方案数 = tmp： 

令 u = lowbit (mask) 

枚举mask一个不包含u的子集s，tmp = tmp + f(mask ^ s) * ( 2 ^ num[ s ] );

上面的式子可以理解为枚举一个包含u的联通块，然后剩下的点两两之间的边选或者不选，这些边不会连接之前的联通块

f [ mask ] = 2 ^ num( mask) - tmp;

3、F[ mask ] [ n ]表示选取mask状态的点，构成n个联通块的方案数

实际上 f[ mask ]是 F[mask][1] ，剩下的状态压缩DP相对简单

枚举mask，枚举n

令u = lowbit( mask )，枚举mask一个不包含u的子集s

F[ mask ][ n ] = F[ s ][ n-1 ] * F[ mask ^ s ][ 1 ]

上面的式子等价于F[ mask ][ n ] = F [ s ][ n-1 ] * f[ mask ^ s ]

答案即为F[ mask ] [ n ] （mask为所有点都选择的状态，就是2^n - 1）

Pascal对拍已A，卡常没办法，估计如果去年现场做要跪（现在也跪）

const mo=1000000009;
var g:array[0..35000,0..15]of int64;
    f:array[0..35000]of int64;
    two:array[0..200]of int64;
    num:array[0..35000]of longint;
    a:array[0..20,0..20]of longint;
    cas,v,i,t,x,y,sta,max,k1,n,m,j:longint;
    tmp:int64;

function lowbit(x:longint):longint;
begin
 exit(x and (-x));
end;

begin
 assign(input,'hdoj5713.in'); reset(input);
 assign(output,'hdoj5713.out'); rewrite(output);
 readln(cas);
 two[0]:=1;
 for i:=1 to 200 do two[i]:=two[i-1]*2 mod mo;
 for v:=1 to cas do
 begin
  readln(n,m,k1);


  max:=(1<<n)-1;
  for i:=1 to n do
   for j:=1 to n do a[i,j]:=0;
  for i:=1 to max do
  begin
   num[i]:=0; f[i]:=0;
  end;
  for i:=1 to max do
   for j:=1 to n do g[i,j]:=0;
  for i:=1 to m do
  begin
   read(x,y);
   a[x,y]:=1; a[y,x]:=1;
  end;
  for i:=1 to max do
  begin
   x:=lowbit(i); y:=round(ln(x)/ln(2))+1;
   num[i]:=num[i xor x];
   for j:=1 to n do
    if i and (1<<(j-1))>0 then num[i]:=(num[i]+a[y,j]) mod mo;
  end;
  for sta:=1 to max do
  begin
   x:=lowbit(sta);
   t:=sta xor x; y:=t; tmp:=0;
   while t>0 do
   begin
    tmp:=tmp+f[sta xor t]*two[num[t]];
    tmp:=tmp mod mo;
    t:=y and (t-1);
   end;
   f[sta]:=(two[num[sta]]-tmp) mod mo;
  end;
  for i:=1 to max do g[i,1]:=f[i];
  for sta:=1 to max do
   for i:=2 to k1 do
   begin
    x:=lowbit(sta);
    t:=sta xor x; y:=t;
    while t>0 do
    begin
     g[sta,i]:=g[sta,i]+g[t,i-1]*f[sta xor t];
     g[sta,i]:=g[sta,i] mod mo;
     t:=y and (t-1);
    end;


   end;


  writeln('Case #',v,':');
  writeln(g[max,k1]);
 end;

 close(input);
 close(output);
end.

对拍用的C++ 1000+MS

#include <iostream>  
#include <cstdio>  
#include <cstring>  
#define MAXMASK 65537  
#define N 20  
#define mod 1000000009LL  
  
using namespace std;  
  
int e[N][N],n,m,k,MASK,num[MAXMASK];  
long long F[MAXMASK][N],f[MAXMASK];  
  
inline int lowbit(int x){return x & (-x);};  
  
int edge(int s, int p) {  
    int ans = 0;  
    for (int i = 1; i <= n; i++)   
        if ((1<<(i-1)) == p) {p = i;break;}  
    for (int i = 1; i <= n; i++) if ((1<<(i-1))&s) ans += e[i][p];  
    return ans;  
}  
  
int main()  
{  
   freopen("hdoj5713.in","r",stdin);
   freopen("right.out","w",stdout);
    int T = 0;  
    scanf("%d",&T);  
    for (int rank=1;rank<=T;rank++)  
    {  
        memset(e,0,sizeof(e));  
        memset(F,0,sizeof(F));  
        memset(f,0,sizeof(f));  
        memset(num,0,sizeof(num));  
        scanf("%d%d%d",&n,&m,&k);  
        MASK = (1 << n) - 1;  
        for (int i=1;i<=m;i++) {  
            int a,b;  
            scanf("%d%d",&a,&b);  
            e[a][b] = e[b][a] = 1;//顺带处理自环:)   
        }  
        //计算mask状态下的边数   
        for (int i=1;i<=MASK;i++) {  
            int t = lowbit(i);  
            num[i] = num[i^t] + edge(i,t);//往状态里新增加一个点   
        }  
          
        //状态压缩DP求小f   
          
        for (int s=1;s<=MASK;s++){  
            int t = lowbit(s);  
            long long tmp = 0LL;  
            for (int i=(s^t);i>0;i=((i-1)&(s^t))) {  
                tmp += f[s^i] * 1LL*(1LL << num[i]);  
                tmp %= mod;  
            }  
            f[s] = (1LL*(1LL<<num[s]) - tmp) % mod;  
        }  
       // for (int s=1;s<=MASK;s++) printf("%d
",f[s]);
        //小f为大F的第一项   
        for (int s=1;s<=MASK;s++) F[s][1] = f[s];  
          
        //状态压缩DP求大F   
        for (int s=1;s<=MASK;s++)  
            for (int i=2;i<=k;i++) {  
                int t = lowbit(s);  
                for (int j=s^t;j>0;j=(j-1)&(s^t))  {//枚举s的子集  
                    F[s][i] += F[j][i-1] * f[s^j];  
                    F[s][i] %= mod;  
                }  
            }  
          
        //防止答案小于0   
        while (F[MASK][k] < 0) F[MASK][k] += mod;  
        printf("Case #%d:
%I64d
", rank, F[MASK][k]);  
    }  
    return 0;  
}