【HDU4609】3-idiots（FFT+计数问题）

概率计算与FFT应用

最新推荐文章于 2019-07-24 09:59:00 发布

原创最新推荐文章于 2019-07-24 09:59:00 发布 · 429 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#fft #组合数学 #计数问题

组合数学同时被 2 个专栏收录

4 篇文章

订阅专栏

数论之FFT

2 篇文章

订阅专栏

本文介绍了一种使用快速傅立叶变换（FFT）解决概率计算问题的方法，具体为计算给定边长能构成三角形的概率。通过将问题转化为多项式乘法，并利用FFT加速计算过程。

记录一个菜逼的成长。。

题目链接
题目大意：
给你n个边长，问能组成三角形的概率

如果用一个多项式A(x), 其x^k的系数ak表示长度为k的树枝的数量, 那么A(x)的平方当中x^k的系数就是从这些树枝中取两根可重复的和为k的排列数, 稍作处理即可得到A[i]数组其中i表示两根树枝的长度和为i, A[i]表示这样的组合数量是A[i]种
sum[i] ：表示两边和为i的组合数的前缀和

具体可见这里

#include <cstdio>
#include <cmath>
#include <cstring>
#include <algorithm>
using namespace std;
#define cl(a,b) memset(a,b,sizeof(a))
typedef long long LL;
const double PI = acos(-1);
const int INF = 0x3f3f3f3f;
struct complex
{
    double r,i;
    complex(double _r = 0.0,double _i = 0.0)
    {
        r = _r; i = _i;
    }
    complex operator +(const complex &b)
    {
        return complex(r+b.r,i+b.i);
    }
    complex operator -(const complex &b)
    {
        return complex(r-b.r,i-b.i);
    }
    complex operator *(const complex &b)
    {
        return complex(r*b.r-i*b.i,r*b.i+i*b.r);
    }
};
///雷德算法--倒位序
void Rader(complex F[],int len)
{
    for( int i = 1,j = len >> 1; i < len-1; i++ ){
        if(i < j)swap(F[i],F[j]);
        int k = len >> 1;
        while(j >= k){
            j -= k;
            k >>= 1;
        }
        if(j < k)j += k;
    }
}
/**
 * 做FFT
 * len必须为2^k形式，
 * on==1时是DFT，on==-1时是IDFT
**/
void fft(complex F[],int len,int dft)
{
    Rader(F,len);
    for( int h = 2; h <= len; h <<= 1 ){
        complex wn(cos(-dft*2*PI/h),sin(-dft*2*PI/h));
        for( int j = 0; j < len; j += h ){
            complex w(1,0);
            for( int k = j; k < j + (h >> 1); k++ ){
                complex u = F[k];
                complex t = w*F[k+(h>>1)];
                F[k] = u + t;
                F[k+(h>>1)] = u - t;
                w = w * wn;
            }
        }
    }
    if(dft == -1)
        for( int i = 0; i < len; i++ )
            F[i].r /= len;
}
void Conv(complex a[],complex b[],int len)
{
    fft(a,len,1);
    fft(b,len,1);
    for( int i = 0; i < len; i++ )
        a[i] = a[i] * b[i];
    fft(a,len,-1);
}
const int maxn = 300000 + 10;
LL num[maxn],A[maxn],sum[maxn];
int branch[maxn];
complex a[maxn];
int main()
{
    int T;scanf("%d",&T);
    while(T--){
        cl(num,0);
        int n,mxlen = 0;
        scanf("%d",&n);
        for( int i = 0; i < n; i++ ){
            scanf("%d",branch+i),mxlen = (mxlen < branch[i] ? branch[i] : mxlen);
            num[branch[i]]++;
        }
        for( int i = 0; i <= mxlen; i++ )
            a[i] = complex(num[i],0);
        int len = 1;
        while(len <= mxlen*2) len <<= 1;
        for( int i = mxlen + 1; i < len; i++ )a[i] = complex(0,0);
        fft(a,len,1);
        for( int i = 0; i < len; i++ )
            a[i] = a[i] * a[i];
        fft(a,len,-1);
        for( int i = 0; i <= 2*mxlen; i++ )
            A[i] = (LL)(a[i].r+0.5);
        for( int i = 0; i <= 2*mxlen; i += 2 )
            A[i] -= num[i>>1];///减掉两根相同的数量
        for( int i = 0; i <= 2*mxlen; i++ )
            A[i] /= 2;///排除顺序的干扰
        ///到现在为止A[i]表示的是去两根不同的branch的长度和为i的组合种数
        sum[0] = 0;
        for( int i = 1; i <= 2*mxlen; i++ ){
            sum[i] = sum[i-1] + A[i];
        }
        LL ans = 0;
        sort(branch,branch+n);
        for( int i = 1; i <= n; i++ ){///以第i根作为边最长的
            LL tmp = sum[2*mxlen] - sum[branch[i]];
            tmp -= (LL)(n-i)*(i-1);///减掉另外两条一条比branch[i]长, 一条不比它长
            tmp -= (LL)(n-i)*(n-i-1)/2;///减掉两条都比他长
            tmp -= n-1;///减掉另外两条的组合中包括它自己的组合
            ans += tmp;
        }
        LL tot = (LL)n*(n-1)*(n-2)/6;///总共有这么多取法
        printf("%.7f\n",(double)ans/tot);
    }
    return 0;
}