BZOJ3198 容斥+hash+恰好

35.BZOJ3198 容斥定理+哈希+恰好 

题意：

n个城市，每个城市有6个属性，求恰好有K个属性相同的城市有多少对？

n<=1e5，0<=k<=6

思路：

恰好为K转化为至少为K，跟34一样，容斥系数是C（i,k）

暴力枚举2^K,对每个状态 看有多少对，挂链哈希，自然溢出取模

比如状态为15(001111)，哈希判断后4个属性有多少对相同的

代码是转的，加了注释= =

代码原博主链接：https://blog.youkuaiyun.com/PoPoQQQ/article/details/43234333

#define M 100100
#define BASE 999911657
using namespace std;
const int C[7][7]={
    {1,0,0,0,0,0,0},
    {1,1,0,0,0,0,0},
    {1,2,1,0,0,0,0},
    {1,3,3,1,0,0,0},
    {1,4,6,4,1,0,0},
    {1,5,10,10,5,1,0},
    {1,6,15,20,15,6,1},
};
int n,k;
int a[M][6];
int digit[64];
long long ans;
namespace Hash_Set{
    struct List{
        List *next;
        unsigned long long hash;
        int val;
        List() {}
        List(List *_,unsigned long long __):
            next(_),hash(__),val(0) {}
    }*head[1001001],mempool[M],*C=mempool;
    int tim[1001001],T;
    inline void Initialize()
    {
        ++T;C=mempool;
    }
    //挂链上，对pos相同的暴力遍历链 找hash 
    //但是如果两个状态 hash相同在同一链上就会WA 
    //这里是采取自然溢出
    int& Hash(unsigned long long hash)
    {
        int pos=hash%1001001;
        if(tim[pos]!=T)
            tim[pos]=T,head[pos]=0x0;
        for(List *temp=head[pos];temp;temp=temp->next)
            if(temp->hash==hash)
                return temp->val;
        head[pos]=new (C++) List(head[pos],hash);
        return head[pos]->val;
    }
}
long long Calculate(int state)//对每个状态计算对数 
{
    using namespace Hash_Set;
    int i,j;
    long long re=0;
    Initialize();
    for(i=1;i<=n;i++)
    {
        unsigned long long hash=0;
        for(j=1;j<=6;j++)
        {
            if( state&(1<<j-1) )
                (hash*=BASE)+=a[i][j];
        }
        int &val=Hash(hash);//返回6元组状态出现的个数 
        //if(state==63)printf("val=%d\n",val);
        re+=val;//C(n,2),每出现多一次就对 相同对数贡献val 
        val++;
    }
    return re;
}
int main()
{
    int i,j;
    cin>>n>>k;
    for(i=1;i<=n;i++)
        for(j=1;j<=6;j++)
            scanf("%d",&a[i][j]);
    for(i=0;i<64;i++)
    {
        digit[i]=digit[i>>1]+(i&1);//状态i的1的个数 
        if(digit[i]>=k)//套路：恰好K=至少K-至少K+1+至少K+2...... 容斥系数C[i,k] 
        //这里至少为K不是一次性算完，比如i=1011跟i=1101，加法可以分开算贡献 
            ans+=(digit[i]-k&1?-1:1)*Calculate(i)*C[digit[i]][k];
    }
    cout<<ans<<endl;
    return 0;
}