[组合数学][容斥]集合计数

首先我们知考虑只有一种交集

交集的大小为K，那么有2^N-K个子集包含了这K个元素（确定K个元素，再从剩下N-K个元素任意选取，有2^N-K种组合）

用这2^N-K个子集能有2^(2^(N-K))种组合，再减去1个空集

一共有C^K_N种交集，这样得出tmp(K)=C^K_N *(2^(2^(N-K)-1)种方法

这里面包含了交集大小大于K的取法，所以还要进行容斥

对于交集大小为L，有tmp(L)=C^L_N *(2^(2^(N-L)-1)种取法

但是tmp(K)多的不止一倍的tmp(L),因为对于每一种交集都多加了tmp(L)

多出C^KL 倍

例如：

　　集合为{A,B,C,D,E}，K=2

　　tmp(K)包含了交集大小为K,K+1,K+2...N的取法种数

　　合法的交集是AB，AC，AD...

　　但是出现了像BCDE这样不合法的交集

　　只计算交集为BC时多余BCDE交集，算BD,BE...同样多出

　　所以BCDE被多算了C²₄次

容斥的话，L-N是奇数就减去C^KL  *tmp(L),L-N是偶数就加上C^KL  *tmp(L)

#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
const long long p=(int)1e9+7;
const int MAXN=(int)1e6+100;
int N,K;
long long fac[MAXN],faci[MAXN];
long long qp[MAXN];   //2^2^i
long long ans=0;
long long qpow(long long a,long long b,long long p){
    if(a==0)
        return 0;
    a%=p;
    long long out=1;
    while(b){
        if(b&1)
             out=(out*a)%p;
        b>>=1;
        a=(a*a)%p;
    }
    return out;
}

long long C(int n,int m){
    if(m>n)
        return 0;
    return ((fac[n]*faci[m]%p)*faci[n-m])%p;
}

long long T(int i){    //2^(2^(N-i))
    return qp[N-i]-1;
}

int main(){
    scanf("%d%d",&N,&K);
    qp[0]=2;
    qp[1]=4;
    for(int i=2;i<=N;++i)
        qp[i]=qp[i-1]*qp[i-1]%p;
    fac[0]=faci[0]=1;
    for(int i=1;i<=N;++i)
        fac[i]=(fac[i-1]*i)%p;
    faci[N]=qpow(fac[N],p-2,p);
    for(int i=N-1;i>=1;--i)
        faci[i]=(faci[i+1]*(i+1))%p;
    ans=C(N,K)*T(K)%p;
    for(int i=K+1;i<=N;++i){
        long long fg=( (i-K) & 1 ) ? -1:1;
        ans+=(fg*C(i,K)*C(N,i)%p)*T(i)%p;
        ans=(ans+p)%p;
    }
    printf("%lld
",ans);
}