HDU 5713 & 2016"百度之星" 複賽（Astar Round3）1002 k個聯通塊

題意：衆所周知，度度熊喜歡圖，尤其是聯通的圖。
今天，它在圖上又玩出了新花樣，新高度。有一張無重邊的無向圖， 求有多少個邊集，使得刪掉邊集裏的邊後，圖裏恰好有K個連通塊。

思路：首先可以很容易想到狀態壓縮，但比賽的時候複雜度算錯了導致寫掛了…….由二項展開可以知道枚舉所有子集的所有子集的複雜度應該是O(3n) 而不是O(4n) 。

這道題用狀態dp[s][k] 表示點集爲s，k個聯通塊的邊集數量，那麼可以得到一個狀態轉移方程
dp[s][k]=sigma(dp[s1][k−1]+f[s ^s1])
其中s1 是s 的一個子集，f[s] 表示s這個點集爲一個聯通塊的邊集數量，可能重複枚舉，所以我們每次只枚舉lowbit(s) 這個點所在的連通塊，那麼我們現在的任務就是計算f[s] 了。
直接計算f[s] 並不好做，我們可以先計算使這個點集不連通的方案數然後用總方案數減去不連通的方案就是f[s]
假設使這個點集不連通的方案數爲h[s] ,那麼可以用類似計算dp數組的方法計算，狀態轉移方程爲
h[s]=sigma(f[s1]∗g[s ^s1])
其中g數組是這個邊集中總的方案數，也就是說我們每次枚舉lowbit(s) 所在的連通塊，因爲總的是不連通的，所以剩下的部分可以任意取邊，所以我們就可以得到如上的狀態轉移方程。
所以我們只需要再預處理每個點集的邊的總數然後按照上述算法來計算即可。

#include<cstdio>
#include<cstring>
#include<cmath>
#include<cstdlib>
#include<iostream>
#include<algorithm>
#include<vector>
#include<map>
#include<queue>
#include<stack>
#include<string>
#include<map>
#include<set>
#include<ctime>
#define eps 1e-6
#define LL long long
#define pii pair<int, int>
//#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
const int mod = 1e9+9;
const int maxn = 15;

int n, m, q, num[1<<maxn], G[maxn][maxn];
LL f[1<<maxn], h[1<<maxn], p[maxn*maxn], dp[1<<maxn][maxn];
void init() {
    memset(G, 0, sizeof(G));
    memset(num, 0, sizeof(num));
    memset(f, 0, sizeof(f));
    memset(h, 0, sizeof(h));
}
inline int lowbit(int x) {
    return x&-x;
}
int cal_edge(int e, int s) {
    int ans = 0;
    for (int i = 0; i < n; i++) 
        if ((1<<i) == e) {
            e = i;
            break;
        }
    for (int i = 0; i < n; i++) 
        if ((1<<i)&s)
            ans += G[i][e];
    return ans;
}

int main()
{
    freopen("input.txt", "r", stdin);
    int T;
    cin >> T;
    int kase = 0;
    p[0] = 1;
    for (int i = 1; i <= 200; i++) {
        p[i] = p[i-1] << 1;
        p[i] %= mod;
    }
    while (T--) {
        scanf("%d%d%d", &n, &m, &q);
        init();
        int maxs = 1 << n;
        for (int i = 1; i <= m; i++) {
            int u, v;
            scanf("%d%d", &u, &v);
            u--;
            v--;
            G[u][v] = G[v][u] = 1;
        }
        num[0] = 0;
        for (int i = 1; i < maxs; i++) {
            int t = lowbit(i);
            num[i] = num[i^t] + cal_edge(t, i);
        } 
        for (int i = 0; i < n; i++) 
            f[1<<i] = p[num[1<<i]];
        for (int i = 1; i < maxs; i++) {
            int t = lowbit(i);
            for (int j = i^t; j; j=(j-1)&(i^t)) {
                h[i] += f[i^j] * p[num[j]];
                h[i] %= mod;
            }
            f[i] = p[num[i]] - h[i];
            f[i] %= mod; 
        }
        for (int i = 1; i < maxs; i++)
            dp[i][1] = f[i];
        for (int i = 1; i < maxs; i++) {
            for (int k = 2; k <= q; k++) {
                dp[i][k] = 0;
                int t = lowbit(i);
                for (int j = i^t; j; j=(j-1)&(i^t)) {
                    dp[i][k] += dp[j][k-1] * f[i^j];
                    dp[i][k] %= mod;
                }
            }
        }
        if (dp[maxs-1][q] < 0)
            dp[maxs-1][q] += mod;
        printf("Case #%d:\n%I64d\n", ++kase, dp[maxs-1][q]);
    }
    return 0;
}