【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=;
 var g:array[..,..]of int64;
     f:array[..]of int64;
     two:array[..]of int64;
     num:array[..]of longint;
     a:array[..,..]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[]:=;
  for i:= to  do two[i]:=two[i-]* mod mo;
  for v:= to cas do
  begin
   readln(n,m,k1);

   max:=(<<n)-;
   for i:= to n do
    for j:= to n do a[i,j]:=;
   for i:= to max do
   begin
    num[i]:=; f[i]:=;
   end;
   for i:= to max do
    for j:= to n do g[i,j]:=;
   for i:= to m do
   begin
    read(x,y);
    a[x,y]:=; a[y,x]:=;
   end;
   for i:= to max do
   begin
    x:=lowbit(i); y:=round(ln(x)/ln())+;
    num[i]:=num[i xor x];
    for j:= to n do
     if i and (<<(j-))> then num[i]:=(num[i]+a[y,j]) mod mo;
   end;
   for sta:= to max do
   begin
    x:=lowbit(sta);
    t:=sta xor x; y:=t; tmp:=;
    while t> do
    begin
     tmp:=tmp+f[sta xor t]*two[num[t]];
     tmp:=tmp mod mo;
     t:=y and (t-);
    end;
    f[sta]:=(two[num[sta]]-tmp) mod mo;
   end;
   for i:= to max do g[i,]:=f[i];
   for sta:= to max do
    for i:= to k1 do
    begin
     x:=lowbit(sta);
     t:=sta xor x; y:=t;
     while t> do
     begin
      g[sta,i]:=g[sta,i]+g[t,i-]*f[sta xor t];
      g[sta,i]:=g[sta,i] mod mo;
      t:=y and (t-);
     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 = ;
     for (int i = ; i <= n; i++)
         if ((<<(i-)) == p) {p = i;break;}
     for (int i = ; i <= n; i++) if ((<<(i-))&s) ans += e[i][p];
     return ans;
 }  

 int main()
 {
    freopen("hdoj5713.in","r",stdin);
    freopen("right.out","w",stdout);
     int T = ;
     scanf("%d",&T);
     for (int rank=;rank<=T;rank++)
     {
         memset(e,,sizeof(e));
         memset(F,,sizeof(F));
         memset(f,,sizeof(f));
         memset(num,,sizeof(num));
         scanf("%d%d%d",&n,&m,&k);
         MASK = ( << n) - ;
         for (int i=;i<=m;i++) {
             int a,b;
             scanf("%d%d",&a,&b);
             e[a][b] = e[b][a] = ;//顺带处理自环:)
         }
         //计算mask状态下的边数
         for (int i=;i<=MASK;i++) {
             int t = lowbit(i);
             num[i] = num[i^t] + edge(i,t);//往状态里新增加一个点
         }  

         //状态压缩DP求小f   

         for (int s=;s<=MASK;s++){
             int t = lowbit(s);
             long long tmp = 0LL;
             for (int i=(s^t);i>;i=((i-)&(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\n",f[s]);
         //小f为大F的第一项
         for (int s=;s<=MASK;s++) F[s][] = f[s];  

         //状态压缩DP求大F
         for (int s=;s<=MASK;s++)
             for (int i=;i<=k;i++) {
                 int t = lowbit(s);
                 for (int j=s^t;j>;j=(j-)&(s^t))  {//枚举s的子集
                     F[s][i] += F[j][i-] * f[s^j];
                     F[s][i] %= mod;
                 }
             }  

         //防止答案小于0
         while (F[MASK][k] < ) F[MASK][k] += mod;
         printf("Case #%d:\n%I64d\n", rank, F[MASK][k]);
     }
     return ;
 }