HDU 4093 Xavier is Learning to Count FFT + 容斥原理 2011年上海现场赛C题

题目大意：
就是现在给出m个不同的正整数, 每个数不超过13000, 也就是说$m\le13000$, 现在每组测试数据给出一个正整数$p(1\le p \le 5)$, 要求出从这m个数中取出不同的p个数的和可能是多少, 对于每一种可能的和求出有多少种方案

大致思路：
首先如果不限制每个数只能取1次的话, 可以直接构造多项式进行乘法来得到结果, 通过FFT加速多项式乘法可以很快得到结果
但是现在需要考虑每个数都不相同, 需要用到容斥
整体来说感觉这题还是有点繁琐的, 对于p的5个取值都是手推的容斥公式…
首先记输入的数组是$a[m]$
首先我们用 $F[1]$ 表示取1个数的可能和的方案, 用$x^k$的系数为1表示存在一个数是k, 否则其系数是0
用$F[2]$表示取同一个数两次可能的和的方案, 当然在$F[2]$中$x^k$系数是1表示在m个数中存在$\frac{k}{2}这个数$, 否则为0
同理依次用多项式$F[i] = \mathop{\Sigma}_{j = 0}^{65536}a_jx^j$表示取某个数$i$次的和
即$F[i]$中$a_j = 1$当且仅当输入的数组中存在$a[k]$使得$j = i*a[k]$, 否则$a_j = 0$
那么通过这一系列的多项式可以用容斥来得到取的个数互补相同的方案数

首先从$p = 1$开始看起
当$p = 1$时, $F[1]$中$a_j$的值代表的便是和为取一个数和为$j$的方案数, 根据其系数输出即可


当$p = 2$时, 由$F[1]*F[1]$可得取两个, 可重复取, 不同的排列算多个, 那么
$F[1]*F[1]$中包含的结果有：
   类型    计算次数
$(x_1, x_2)$    $2$次
$(x_1, x_1)$    $1$次
记$F[1]*F[1]$结果向量为 $(2, 1)$

而$F[2]$中包含的结果有
   类型    计算次数
$(x_1, x_2)$    $0$次
$(x_1, x_1)$    $1$次
结果向量为$(0, 1)$
而我们需要的结果向量是$(x_1, x_2)$类型算1次, 即$(1, 0)$
那么多项式$\frac{F[1]*F[1] - F[2]}{2}$ 的系数即为我们需要的东西了

类似的, $p = 3$时
$F[1]*F[1]*F[1]$中包含的结果有
      类型        计算次数
$(x_1, x_2, x_3)$     $6$次
$(x_1, x_1, x_2)$     $3$次
$(x_1, x_1, x_1)$     $1$次
$F[1]*F[1]*F[1]$结果向量为 $(6, 3, 1)$

而$F[2]*F[1]$包含的结果有
      类型        计算次数
$(x_1, x_2, x_3)$     $0$次
$(x_1, x_1, x_2)$     $1$次
$(x_1, x_1, x_1)$     $1$次
$F[2]*F[1]$结果向量为 $(0, 1, 1)$

$F[3]$包含的结果有
      类型        计算次数
$(x_1, x_2, x_3)$     $0$次
$(x_1, x_1, x_2)$     $0$次
$(x_1, x_1, x_1)$     $1$次
$F[3]$结果向量为 $(0, 0, 1)$
为了得到结果$(1, 0, 0)$很明显是多项式$\frac{F[1]^3 - 3F[1]*F[2] + F[3]}{3!}$

当$p = 4$时
$F[1]^4$代表统计的结果有
        类型            计算次数
$(x_1, x_2, x_3, x_4)$    $24$次
$(x_1, x_1, x_2, x_3)$    $12$次
$(x_1, x_1, x_2, x_2)$    $6$次
$(x_1, x_1, x_1, x_2)$    $4$次
$(x_1, x_1, x_1, x_1)$    $1$次
$F[1]^4$结果向量为 $(24, 12, 6, 4, 1)$

$F[2]*F[1]*F[1]$代表统计的结果有
        类型            计算次数
$(x_1, x_2, x_3, x_4)$    $0$次
$(x_1, x_1, x_2, x_3)$    $2$次
$(x_1, x_1, x_2, x_2)$    $2$次
$(x_1, x_1, x_1, x_2)$    $2$次
$(x_1, x_1, x_1, x_1)$    $1$次
$F[2]*F[1]*F[1]$结果向量为 $(0, 2, 2, 2, 1)$

$F[2]*F[2]$代表统计的结果有
        类型            计算次数
$(x_1, x_2, x_3, x_4)$    $0$次
$(x_1, x_1, x_2, x_3)$    $0$次
$(x_1, x_1, x_2, x_2)$    $2$次
$(x_1, x_1, x_1, x_2)$    $0$次
$(x_1, x_1, x_1, x_1)$    $1$次
$F[2]*F[2]$结果向量为 $(0, 0, 2, 0, 1)$

$F[3]*F[1]$代表统计的结果有
        类型            计算次数
$(x_1, x_2, x_3, x_4)$    $0$次
$(x_1, x_1, x_2, x_3)$    $0$次
$(x_1, x_1, x_2, x_2)$    $0$次
$(x_1, x_1, x_1, x_2)$    $1$次
$(x_1, x_1, x_1, x_1)$    $1$次
$F[3]*F[1]$结果向量为 $(0, 0, 0, 1, 1)$

$F[4]$代表的统计结果有
        类型            计算次数
$(x_1, x_2, x_3, x_4)$    $0$次
$(x_1, x_1, x_2, x_3)$    $0$次
$(x_1, x_1, x_2, x_2)$    $0$次
$(x_1, x_1, x_1, x_2)$    $0$次
$(x_1, x_1, x_1, x_1)$    $1$次
$F[4]$结果向量为 $(0, 0, 0, 0, 1)$
与上面的同理需要的是$(1, 0, 0, 0, 0)$
需要的多项式是$\frac{F[1]^4 - 6F[2]*F[1]^2 + 3F[2]^2 + 8F[3]*F[1] - 6F[4]}{4!}$

当$p = 5$时
$F[1]^5$代表的结果有
            类型                计算次数
$(x_1, x_2, x_3, x_4, x_5)$    $120$次
$(x_1, x_1, x_2, x_3, x_4)$    $60$次
$(x_1, x_1, x_2, x_2, x_3)$    $30$次
$(x_1, x_1, x_1, x_2, x_3)$    $20$次
$(x_1, x_1, x_1, x_2, x_2)$    $10$次
$(x_1, x_1, x_1, x_1, x_2)$    $5$次
$(x_1, x_1, x_1, x_1, x_1)$    $1$次
$F[1]^5$结果向量为 $(120, 60, 30, 20, 10, 5, 1)$

$F[2]*F[1]^3$代表的结果有
            类型                计算次数
$(x_1, x_2, x_3, x_4, x_5)$    $0$次
$(x_1, x_1, x_2, x_3, x_4)$    $6$次
$(x_1, x_1, x_2, x_2, x_3)$    $6$次
$(x_1, x_1, x_1, x_2, x_3)$    $6$次
$(x_1, x_1, x_1, x_2, x_2)$    $4$次
$(x_1, x_1, x_1, x_1, x_2)$    $3$次
$(x_1, x_1, x_1, x_1, x_1)$    $1$次
$F[2]*F[1]^3$结果向量为 $(0, 6, 6, 6, 4, 3, 1)$

$F[2]^2*F[1]$代表的结果有
            类型                计算次数
$(x_1, x_2, x_3, x_4, x_5)$    $0$次
$(x_1, x_1, x_2, x_3, x_4)$    $0$次
$(x_1, x_1, x_2, x_2, x_3)$    $2$次
$(x_1, x_1, x_1, x_2, x_3)$    $0$次
$(x_1, x_1, x_1, x_2, x_2)$    $2$次
$(x_1, x_1, x_1, x_1, x_2)$    $1$次
$(x_1, x_1, x_1, x_1, x_1)$    $1$次
$F[2]^2*F[1]$结果向量为 $(0, 0, 2, 0, 2, 1, 1)$

$F[3]*F[1]^2$代表的结果有
            类型                计算次数
$(x_1, x_2, x_3, x_4, x_5)$    $0$次
$(x_1, x_1, x_2, x_3, x_4)$    $0$次
$(x_1, x_1, x_2, x_2, x_3)$    $0$次
$(x_1, x_1, x_1, x_2, x_3)$    $2$次
$(x_1, x_1, x_1, x_2, x_2)$    $1$次
$(x_1, x_1, x_1, x_1, x_2)$    $2$次
$(x_1, x_1, x_1, x_1, x_1)$    $1$次
$F[3]*F[1]^2$结果向量为 $(0, 0, 0, 2, 1, 2, 1)$

$F[3]*F[2]$代表的结果有
            类型                计算次数
$(x_1, x_2, x_3, x_4, x_5)$    $0$次
$(x_1, x_1, x_2, x_3, x_4)$    $0$次
$(x_1, x_1, x_2, x_2, x_3)$    $0$次
$(x_1, x_1, x_1, x_2, x_3)$    $0$次
$(x_1, x_1, x_1, x_2, x_2)$    $1$次
$(x_1, x_1, x_1, x_1, x_2)$    $0$次
$(x_1, x_1, x_1, x_1, x_1)$    $1$次
$F[3]*F[2]$结果向量为 $(0, 0, 0, 0, 1, 0, 1)$

$F[4]*F[1]$代表的结果有
            类型                计算次数
$(x_1, x_2, x_3, x_4, x_5)$    $0$次
$(x_1, x_1, x_2, x_3, x_4)$    $0$次
$(x_1, x_1, x_2, x_2, x_3)$    $0$次
$(x_1, x_1, x_1, x_2, x_3)$    $0$次
$(x_1, x_1, x_1, x_2, x_2)$    $0$次
$(x_1, x_1, x_1, x_1, x_2)$    $1$次
$(x_1, x_1, x_1, x_1, x_1)$    $1$次
$F[4]*F[1]$结果向量为 $(0, 0, 0, 0, 0, 1, 1)$

$F[5]$代表的结果有
            类型                计算次数
$(x_1, x_2, x_3, x_4, x_5)$    $0$次
$(x_1, x_1, x_2, x_3, x_4)$    $0$次
$(x_1, x_1, x_2, x_2, x_3)$    $0$次
$(x_1, x_1, x_1, x_2, x_3)$    $0$次
$(x_1, x_1, x_1, x_2, x_2)$    $0$次
$(x_1, x_1, x_1, x_1, x_2)$    $0$次
$(x_1, x_1, x_1, x_1, x_1)$    $1$次
$F[5]$结果向量为 $(0, 0, 0, 0, 0, 0, 1)$
为了得到结果向量$(1, 0, 0, 0, 0, 0, 0)$ 当然是$\frac{F[1]^5 - 10F[2]*F[1]^3 + 15F[2]^2*F[1] + 20F[3]*F[1]^2 - 20F[3]*F[2] -30F[4]*F[1] + 24F[5]}{5!}$

至此整个问题就转变成多项式乘法的问题了, 用FFT可以$O(nlogn)$解决不会FFT可以参考这个写的学习笔记`

应该是精度问题我换了long double交G++才通过…
代码如下:
Result : Accepted Memory : 28324 KB Time : 2028 ms

/*
 * Author: Gatevin
 * Created Time:  2015/7/24 16:03:01
 * File Name: E.cpp
 */
#include<iostream>
#include<sstream>
#include<fstream>
#include<vector>
#include<list>
#include<deque>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<cmath>
#include<ctime>
#include<iomanip>
using namespace std;
const double eps(1e-8);
typedef long long lint;

const long double PI = acos(-1.0);

struct Complex
{
    long double real, image;
    Complex(long double _real, long double _image)
    {
        real = _real;
        image = _image;
    }
    Complex(){}
};

Complex operator + (const Complex &c1, const Complex &c2)
{
    return Complex(c1.real + c2.real, c1.image + c2.image);
}

Complex operator - (const Complex &c1, const Complex &c2)
{
    return Complex(c1.real - c2.real, c1.image - c2.image);
}

Complex operator * (const Complex &c1, const Complex &c2)
{
    return Complex(c1.real*c2.real - c1.image*c2.image, c1.real*c2.image + c1.image*c2.real);
}

int rev(int id, int len)
{
    int ret = 0;
    for(int i = 0; (1 << i) < len; i++)
    {
        ret <<= 1;
        if(id & (1 << i)) ret |= 1;
    }
    return ret;
}

Complex A[1 << 16];
void FFT(Complex *a, int len, int DFT)
{
    for(int i = 0; i < len; i++) A[rev(i, len)] = a[i];
    for(int s = 1; (1 << s) <= len; s++)
    {
        int m = (1 << s);
        Complex wm = Complex(cos(DFT*2*PI/m), sin(DFT*2*PI/m));
        for(int k = 0; k < len; k += m)
        {
            Complex w = Complex(1, 0);
            for(int j = 0; j < (m >> 1); j++)
            {
                Complex t = w*A[k + j + (m >> 1)];
                Complex u = A[k + j];
                A[k + j] = u + t;
                A[k + j + (m >> 1)] = u - t;
                w = w*wm;
            }
        }
    }
    if(DFT == -1) for(int i = 0; i < len; i++) A[i].real /= len, A[i].image /= len;
    for(int i = 0; i < len; i++) a[i] = A[i];
}

int polynomialLength;//多项式最大长度

void multiply(Complex *p1, Complex *p2)//多项式点值相乘
{
    for(int i = 0; i < polynomialLength; i++)
        p1[i] = p1[i]*p2[i];
    return;
}

void Copy(Complex *p1, Complex *p2)//将p2多项式赋值给p1多项式
{
    for(int i = 0; i < polynomialLength; i++)
        p1[i] = p2[i];
    return;
}

int a[13010];
int p, m;
Complex f[6][1 << 16];
Complex g[7][1 << 16];

const int par[6][10] = //容斥系数
{
    {0},//无效的
    {1},
    {1, -1},
    {1, -3, 2},
    {1, -6, 3, 8, -6},
    {1, -10, 15, 20, -20, -30, 24}
};

void solve()
{
    int maxL = 0;
    for(int i = 1; i <= m; i++)
        maxL = max(maxL, a[i]);
    polynomialLength = 1;
    while(polynomialLength <= maxL*p) polynomialLength <<= 1;

    //初始化f[i]多项式表示i*a[i]数组对应的多项式
    for(int i = 1; i <= p; i++)
    {
        for(int j = 0; j < polynomialLength; j++)
            f[i][j] = Complex(0, 0);
        for(int j = 1; j <= m; j++)
            f[i][i*a[j]].real += 1;
        FFT(f[i], polynomialLength, 1);
    }
    int inclusiveLength = -1;//容斥的等式的长度
    switch(p)
    {
        // p == 1 就是原数列, 答案为 f[1]
        case 1: Copy(g[0], f[1]);
                inclusiveLength = 1;
                break;
        //p == 2 结果是(f[1]^2 - f[2]) / 2
        case 2: Copy(g[0], f[1]);
                multiply(g[0], f[1]);
                Copy(g[1], f[2]);
                inclusiveLength = 2;
                break;
        // p == 3 结果是(f[1]^3 - 3*f[2]*f[1] + 2f[3]) / 6
        case 3: Copy(g[0], f[1]);
                multiply(g[0], f[1]); multiply(g[0], f[1]);
                Copy(g[1], f[2]);
                multiply(g[1], f[1]);
                Copy(g[2], f[3]);
                inclusiveLength = 3;
                break;
        // p == 4 结果是(f[1]^4 - 6*f[2]*f[1]*f[1] + 3*f[2]*f[2] + 8f[3]*f[1] - 6*f[4])/24
        case 4: Copy(g[0], f[1]);
                multiply(g[0], f[1]); multiply(g[0], f[1]); multiply(g[0], f[1]);
                Copy(g[1], f[2]);
                multiply(g[1], f[1]); multiply(g[1], f[1]);
                Copy(g[2], f[2]);
                multiply(g[2], f[2]);
                Copy(g[3], f[3]);
                multiply(g[3], f[1]);
                Copy(g[4], f[4]);
                inclusiveLength = 5;
                break;
        // p == 5 结果是 (f[1]^5 - 10*f[2]f[1]^3 + 15*f[2]*f[2]*f[1] + 20*f[3]*f[1]*f[1] - 20*f[3]*f[2] - 30*f[4]*f[1] + 24*f[5])/120
        case 5: Copy(g[0], f[1]);
                multiply(g[0], f[1]); multiply(g[0], f[1]); multiply(g[0], f[1]); multiply(g[0], f[1]);
                Copy(g[1], f[2]);
                multiply(g[1], f[1]); multiply(g[1], f[1]); multiply(g[1], f[1]);
                Copy(g[2], f[2]);
                multiply(g[2], f[2]); multiply(g[2], f[1]);
                Copy(g[3], f[3]);
                multiply(g[3], f[1]); multiply(g[3], f[1]);
                Copy(g[4], f[3]);
                multiply(g[4], f[2]);
                Copy(g[5], f[4]);
                multiply(g[5], f[1]);
                Copy(g[6], f[5]);
                inclusiveLength = 7;
                break;
    }
    for(int i = 0; i < inclusiveLength; i++)
        FFT(g[i], polynomialLength, -1);
    for(int i = 0; i < polynomialLength; i++)
    {
        double res = 0;
        for(int j = 0; j < inclusiveLength; j++)
            res += g[j][i].real*par[p][j];
        for(int j = 1; j <= p; j++) res /= j;
        if(res > 0.5) printf("%d: %.0f\n", i, res);
    }
    return;
}

int main()
{
    int T;
    scanf("%d", &T);
    for(int cas = 1; cas <= T; cas++)
    {
        scanf("%d %d", &m, &p);
        for(int i = 1; i <= m; i++)
            scanf("%d", &a[i]);
        printf("Case #%d:\n", cas);
        solve();
        putchar('\n');
    }
    return 0;
}