洛谷P3298 泉

时空限制 1000ms / 128MB

题目描述

作为光荣的济南泉历史研究小组中的一员，铭铭收集了历史上x个不同年份时不同泉区的水流指数，这个指数是一个小于. 2^30的非负整数。第i个年份时六个泉区的泉水流量指数分别为 A(i,l)，A(i,2)，A(i,3)，A(i,4)， A(i,5)与 A(i,6)。

现在铭铭希望知道有多少对不同的年份：i和j,满足这两年恰好有K个泉区的泉水流S指数对应相同。

输入输出格式

输入格式：

第一行有2个整数，分别是N和K

之后N行，每行有6个整数。第i行的第j个数字A(i，j)表示第i个年份中第j个泉区的泉水流量指数。

输出格式：

一个整数表示有多少对不同的年份满足恰有K个区的泉水流量指数对应相同。

输入输出样例

输入样例#1：
复制

3 3
1 2 3 4 5 6
1 2 3 0 0 0
0 0 0 4 5 6

输出样例#1： 复制

2

说明

对于 100%的数据, 0<=K <=6, 且所有数据中K是等概率出现的, 即对于任意的 0<=x都有大约 1/7 的数据中 K=x. N<=100000

---

解：稍加思索，发现我们可以枚举是哪k个相等，但是这样会算重，所以容斥一下。发现2⁶ = 64，有搞头。

这样问题转化成了给定一个6元组组成的序列，判断其中有多少个相等的。显然只要hash就行了。那么如何对一个6元组hash呢？red sun一语惊醒我：字符串hash啊。

注意这题容斥的时候要乘组合数，可能只有我没乘组合数还一直以为是hash的锅......

 #include <bits/stdc++.h>

 typedef unsigned long long uLL;
 typedef long long LL;
 const int N = ;
 const uLL B = , MO = ;

 uLL pwB[], h[N][], pw2[], h2[N][];
 int a[N][], n, k, cnt[], pw[N];
 LL C[][];

 inline uLL getHash(int x) {
     uLL ans = ;
     for(int i = ; i < ; i++) {
         ans = ans * B + (x % ) + '';
         x /= ;
     }
     return ans;
 }
 inline uLL getHash2(int x) {
     uLL ans = ;
     for(int i = ; i < ; i++) {
         ans = (ans * B % MO + (x & ) + '') % MO;
         x >>= ;
     }
     return ans;
 }

 namespace Hash {
     struct Node {
         int cnt, nex;
         uLL val, val2;
     }node[N]; int tp;
     const int mod = ;
     int e[mod];
     inline int insert(uLL v, uLL v2) {
         int x = v % mod;
         for(int i = e[x]; i; i = node[i].nex) {
             if(node[i].val == v && node[i].val2 == v2) {
                 return node[i].cnt++;
             }
         }
         node[++tp].val = v;
         node[tp].val2 = v2;
         node[tp].cnt = ;
         node[tp].nex = e[x];
         e[x] = tp;
         return ;
     }
     inline void clear() {
         memset(e, , sizeof(e));
         tp = ;
         return;
     }
 }

 int main() {
     for(int i = ; i <= ; i++) {
         C[i][] = C[i][i] = ;
         for(int j = ; j < i; j++) {
             C[i][j] = C[i - ][j] + C[i - ][j - ];
         }
     }
     scanf("%d%d", &n, &k);
     for(int i = ; i <= n; i++) {
         for(int j = ; j < ; j++) {
             scanf("%d", &a[i][j]);
             h[i][j] = getHash(a[i][j]);
             h2[i][j] = getHash2(a[i][j]);
         }
     }

     int lm = ( << );
     for(int s = ; s < lm; s++) {
         cnt[s] =  + cnt[s - (s & (-s))];
     }
     pw2[] = pwB[] = ;
     for(int i = ; i < ; i++) {
         pw[ << i] = i;
     }
     for(int i = ; i < ; i++) {
         pwB[i + ] = pwB[i] * B;
         pw2[i + ] = pw2[i] * B % MO;
     }
     LL fin = ;
     for(int s = ; s < lm; s++) {
         if(cnt[s] < k) {
             continue;
         }
         LL ans = ;
         Hash::clear();
         for(int i = ; i <= n; i++) {
             uLL temp = , t2 = ;
             int ss = s;
             while(ss) {

                 int t = pw[ss & (-ss)];
                 temp = temp * pwB[] + h[i][t];
                 t2 = (t2 * pw2[] % MO + h2[i][t]) % MO;

                 ss ^= ( << t);
             }
             ans += Hash::insert(temp, t2);
         }
         ans = ans * C[cnt[s]][k];
         if((cnt[s] - k) & ) {
             fin -= ans;
         }
         else {
             fin += ans;
         }
     }

     printf("%lld\n", fin);
     return ;
 }

AC代码