[ZJOI2016]小星星

题目

我太傻了，我竟然能搞错容斥系数

首先会发现一个直接状压的做法，就是设\(dp[i][j][S]\)表示点映射的点是\(j\)，在\(i\)的子树里用的点的集合是\(S\)

转移怕不是需要枚举子集，复杂度大概\(O(3^nn^2)\)吧

显然不能过啊

我们考虑容斥

我们设\(dp[i][j]\)表示点\(i\)映射到点\(j\)的方案数，我们不考虑算重的问题，我们直接大力枚举儿子映射的对象是什么就好

这样显然会算重，我们考虑容斥

我们发现我们如果使用全集来进行计算的话，算出来的是至少算重\(0\)个的方案数

如果使用\(n-1\)个元素组成的点集来计算的话，得到的是至少算重\(1\)个的方案数

于是可以直接套上容斥了，枚举映射的点集\(S\)，容斥系数就是\((-1)^{n-|S|}\)，复杂度\(O(2^nn^3)\)

代码

#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<vector>
#define re register
#define LL long long
const int maxn=18;
const int M=150005;
inline int read() {
    char c=getchar();int x=0;while(c<'0'||x>'9') c=getchar();
    while(c>='0'&&c<='9') x=(x<<3)+(x<<1)+c-48,c=getchar();return x;
}
struct E{int v,nxt;}e[maxn<<1];
int n,m,num,top;
int head[maxn],st[maxn];
LL dp[maxn][maxn],ans;
int map[maxn][maxn];
inline void add(int x,int y) {
    e[++num].v=y;e[num].nxt=head[x];head[x]=num;
}
void dfs(int x,int fa) {
    for(re int i=1;i<=top;i++)
        dp[x][st[i]]=1;
    for(re int i=head[x];i;i=e[i].nxt) {
        if(e[i].v==fa) continue;
        dfs(e[i].v,x);
        for(re int j=1;j<=top;j++) {
            int t=st[j];LL now=0;
            for(re int k=1;k<=top;k++) 
                now+=1ll*map[t][st[k]]*dp[e[i].v][st[k]];
            dp[x][t]*=now;
        }
    }
}
inline void solve(int S) {
    top=0;
    for(re int i=1;i<=n;i++)
    if(S&(1<<(i-1))) st[++top]=i;
    memset(dp,0,sizeof(dp));
    dfs(1,0);
    LL o=((n-top)&1)?-1:1;
    for(re int i=1;i<=top;i++)
        ans+=o*dp[1][st[i]];
}
int main() {
    n=read(),m=read();
    for(re int x,y,i=1;i<=m;i++) {
        x=read(),y=read();
        map[x][y]=map[y][x]=1;
    }
    for(re int x,y,i=1;i<n;i++) {
        x=read(),y=read(),add(x,y),add(y,x);
    }
    int N=(1<<n)-1;
    for(re int i=1;i<=N;i++) solve(i);
    printf("%lld\n",ans);
    return 0;
}

转载于:https://www.cnblogs.com/asuldb/p/10678933.html