BZOJ4455 ZJOI2016小星星（容斥原理+树形dp）

　　相当于给树上的每个点分配一个编号使父亲和儿子间都有连边。

　　于是可以考虑树形dp：设f[i][j][k]为i号点的编号为j，其子树中编号集合为k的方案数。转移显然。然而复杂度3ⁿ·n³左右，具体我也不知道是多少，但肯定跑不过。

　　如果状态有集合的话不管怎样底数都是3了，考虑能不能变成2。完全不能可以想到容斥。

　　于是在dp中去掉k这一维。那么dp变成n³的。但是dp显然会有问题，即会出现不同的点取了相同编号的情况。这也可以看做是有编号未被选择。

　　那么就可以容斥了。先算出编号在全集中选择的答案，然后减去在全集去掉一个编号所得子集中选择的答案，再加上在全集去掉两个编号所得子集中选择的答案……通过组合数计算子集被计入的次数容易验证其正确性。

　　枚举子集然后dp，复杂度就是O(2ⁿ·n³)了。注意卡常。

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstdlib>
#include<cstring>
#include<algorithm>
using namespace std;
int read()
{
    int x=,f=;char c=getchar();
    while (c<''||c>'') {if (c=='-') f=-;c=getchar();}
    while (c>=''&&c<='') x=(x<<)+(x<<)+(c^),c=getchar();
    return x*f;
}
#define N 18
#define ll long long
int n,m,a[N][N],stk[N],p[N],t;
ll f[N][N],ans=;
struct data{int to,nxt;
}edge[N<<];
void addedge(int x,int y){t++;edge[t].to=y,edge[t].nxt=p[x],p[x]=t;}
void dp(int k,int from,int s)
{
    memset(f[k],,sizeof(f[k]));
    for (int x=;x<=s;x++)
    f[k][stk[x]]=;
    for (int i=p[k];i;i=edge[i].nxt)
    if (edge[i].to!=from)
    {
        dp(edge[i].to,k,s);
        for (int x=;x<=s;x++)
        {
            ll sum=;
            for (int y=;y<=s;y++)
            if (a[stk[x]][stk[y]]) sum+=f[edge[i].to][stk[y]];
            f[k][stk[x]]=f[k][stk[x]]*sum;
        }
    }
}
void dfs(int k,int s)
{
    if (k>n)
    {
        dp(,,s);
        ll sum=;
        for (int i=;i<=n;i++) sum+=f[][i];
        if (n-s&) ans-=sum;else ans+=sum;
        return;
    }
    stk[s+]=k;dfs(k+,s+);
    dfs(k+,s);
}
int main()
{
#ifndef ONLINE_JUDGE
    freopen("bzoj4455.in","r",stdin);
    freopen("bzoj4455.out","w",stdout);
    const char LL[]="%I64d";
#else
    const char LL[]="%lld";
#endif
    n=read(),m=read();
    while (m--)
    {
        int x=read(),y=read();
        a[x][y]=a[y][x]=;
    }
    for (int i=;i<n;i++)
    {
        int x=read(),y=read();
        addedge(x,y),addedge(y,x);
    }
    dfs(,);
    cout<<ans;
    return ;
}