bzoj3771 Triple（生成函数+容斥+FFT）

Description

我们讲一个悲伤的故事。

从前有一个贫穷的樵夫在河边砍柴。

这时候河里出现了一个水神，夺过了他的斧头，说：

“这把斧头，是不是你的？”

樵夫一看：“是啊是啊！”

水神把斧头扔在一边，又拿起一个东西问：

“这把斧头，是不是你的？”

樵夫看不清楚，但又怕真的是自己的斧头，只好又答：“是啊是啊！”

水神又把手上的东西扔在一边，拿起第三个东西问：

“这把斧头，是不是你的？”

樵夫还是看不清楚，但是他觉得再这样下去他就没法砍柴了。

于是他又一次答：“是啊是啊！真的是！”

水神看着他，哈哈大笑道：

“你看看你现在的样子，真是丑陋！”

之后就消失了。

樵夫觉得很坑爹，他今天不仅没有砍到柴，还丢了一把斧头给那个水神。

于是他准备回家换一把斧头。

回家之后他才发现真正坑爹的事情才刚开始。

水神拿着的的确是他的斧头。

但是不一定是他拿出去的那把，还有可能是水神不知道怎么偷偷从他家里拿走的。

换句话说，水神可能拿走了他的一把，两把或者三把斧头。

樵夫觉得今天真是倒霉透了，但不管怎么样日子还得过。

他想统计他的损失。

樵夫的每一把斧头都有一个价值，不同斧头的价值不同。总损失就是丢掉的斧头价值和。

他想对于每个可能的总损失，计算有几种可能的方案。

注意：如果水神拿走了两把斧头a和b，(a,b)和(b,a)视为一种方案。拿走三把斧头时，(a,b,c),(b,c,a),(c,a,b),(c,b,a),(b,a,c),(a,c,b)视为一种方案。

Input

第一行是整数N，表示有N把斧头。

接下来n行升序输入N个数字Ai，表示每把斧头的价值。

Output

若干行，按升序对于所有可能的总损失输出一行x y，x为损失值，y为方案数。

Sample Input

4
4
5
6
7

Sample Output

4 1
5 1
6 1
7 1
9 1
10 1
11 2
12 1
13 1
15 1
16 1
17 1
18 1

样例解释
11有两种方案是4+7和5+6，其他损失值都有唯一方案，例如4=4,5=5,10=4+6,18=5+6+7.

HINT

所有数据满足：Ai<=40000

[ Submit][ Status][ Discuss] 

分析：
听说要用到生成函数？（生成函数好难！！！）

我们要构造易个生成函数，形式如下：
$A(x)=a_01+a_1x+a_2x^2+a_3x^3+...$
其中$a_i$表示数字i出现的次数
也就说，如果有价值为x的物品，则$a_x=1$

我们经常用生成函数解决如下问题：

求装有苹果，香蕉，橘子和梨的果篮的数量hn，
其中在每个果篮中苹果数是偶数，香蕉数是5的倍数，橘子最多拿4个，梨要么不拿，要么只能拿一个

答案：

资料上，称这个问题为n组合问题

选择1，2，3把斧子的情况，需要分别计算
下面我们就先分析选3把斧子的情况：

那么我们还是可以故伎重演：
我们把樵夫拥有的斧子复制成三份，这样我们就有了三堆斧子
我们先简单的认为，取斧子就是从这三堆中每堆各取一个
那么答案显然是：$A(x)*A(x)*A(x)=A^3(x)$

这里涉及到了生成函数的一个小定理：
$S$是多重集合$\{ n_1·a_1,n_2·a_2,...,n_k·a_k \}$，$h_n$是$S$的$n$排列数，则$h_n$的生成函数为：
$g(x)=f_{n_1}(x)f_{n_2}(x)...f_{n_k}(x)$

但是这样选可能存在有一个东西选了两次或者选了三次的方案数，
要把ta们减去才能求出恰好选了三个不重复的东西的方案数

对于一个物品重复选了两次的情况，我们可以在生成函数中强制选择ta两次：
对于一个价值为i的物品，$a_{2i}=1$
这样得到的生产函数，我们设为$B(x)$
那么$B(x)*A(x)$就是一个物品重复选择两次的方案数

对于一个物品重复选择三次的情况，我们构造生成函数$C(x)$：
对于一个价值为$i$的物品，$a_{3i}=1$

接下来就是容斥的过程

我们看一下最开始得到的选3把斧子的答案：$A(x)*A(x)*A(x)=A^3(x)$
我们在解释这个式子的时候，直接把斧子复制成了三份
所以我们选的第一把斧子，第二把斧子，第三把斧子，ta们之间是没有关系的
也就是说，$A^3(x)$中会有这样的情况：
$(a,a,a),(a,a,b),(a,b,a),(b,a,a)$
这些都是有一把斧子重复选了两次的情况

而$B(x)*A(x)$就是一个物品重复选择两次的方案数
也就是说，$B(x)*A(x)$中的情况都是这样的：$(a,a,a),(a,a,b)$

在$A^3(x)$中，组合$(a,a,b)$出现了三次，$(a,a,a)$出现了一次
如果$A^3(x)-3*B(x)$，我们就可以去掉形如$(a,a,b)$的情况
但是形如$(a,a,a)$的情况我们还是多减了两次，所以我们还要加回来
$A^3(x)-3*B(x)*A(x)+2*C(x)$

然而，我们用生成函数计算的排列的方案数

因为我们还是默认了有第一把斧子，第二把斧子，第三把斧子
所以最后的答案需要除以6：

$A^3(x)-3*B(x)*A(x)+2*C(x) \over 6$

以上就是选三把斧子的情况

依次类推，最后的答案：

${A^3(x)-3*B(x)*A(x)+2*C(x) \over 6}+{A^2(x)-B(x) \over 2}+A(x)$

生成函数的卷积可以用FFT加速

tip

感觉之前对于生成函数有点曲解，其实生成函数计算的也是某种程度上的“排列数”
就像我们经常看到的生成函数例题：

设$h_n$为方程：$e_1+e_2+e_3+e_4=n$的非负整数解的个数

解：生成函数，显然，$e_1,e_2,e_3,e_4$之间是有潜在顺序的

注意fn的大小：$maxnum*3*2$（因为C的大小就有$maxnum*3$，还要乘）
最后的答案要开ll

#include<bits/stdc++.h>
#define ll long long

using namespace std;

const double pi=acos(-1.0);
const int N=400010;
struct node{
    double x,y;
    node (double xx=0,double yy=0) {
        x=xx;y=yy;
    }
};
node A[N],B[N],C[N],o[N],_o[N];
int n,fn;

node operator +(const node &a,const node &b) {return node(a.x+b.x,a.y+b.y);}
node operator -(const node &a,const node &b) {return node(a.x-b.x,a.y-b.y);}
node operator *(const node &a,const node &b) {return node(a.x*b.x-a.y*b.y,a.x*b.y+a.y*b.x);}
node operator /(const node &a,const double &b) {return node(a.x/b,a.y/b);}

void init(int n) {
    for (int i=0;i<=n;i++) {
        o[i]=node(cos(2.0*i*pi/n),sin(2.0*i*pi/n));
        _o[i]=node(cos(2.0*i*pi/n),-sin(2.0*i*pi/n));   //共轭 
    }
}

void FFT(int n,node *a,node *w) {
    int i,j=0,k;
    for (i=0;i<n;i++) {
        if (i>j) swap(a[i],a[j]);
        for (int l=n>>1;(j^=l)<l;l>>=1);
    }
    for (i=2;i<=n;i<<=1) {
        int m=i>>1;
        for (j=0;j<n;j+=i) 
            for (k=0;k<m;k++) {
                node z=a[j+k+m]*w[n/i*k];
                a[j+k+m]=a[j+k]-z;
                a[j+k]=a[j+k]+z;
            }
    }
}

int main()
{
    scanf("%d",&n);
    int mx=0;
    for (int i=1;i<=n;i++) {
        int x;
        scanf("%d",&x);
        A[x].x++; B[x*2].x++; C[3*x].x++;
        mx=max(mx,3*x);
    }

    fn=1;
    while (fn<=mx+mx) fn<<=1;

    init(fn);
    FFT(fn,A,o);
    FFT(fn,B,o);
    FFT(fn,C,o);

    node a(6.0,0),b(3.0,0),c(2.0,0);     //复数运算 
    for (int i=0;i<=fn;i++) 
        A[i]=(A[i]*A[i]*A[i]-b*A[i]*B[i]+c*C[i])/6.0
            +(A[i]*A[i]-B[i])/2.0+A[i]; 

    FFT(fn,A,_o);
    for (int i=1;i<=mx*2;i++) {
        ll ans=(ll)(A[i].x/fn+0.5);
        if (ans) printf("%d %lld\n",i,ans);
    }

    return 0;
}