HDU 4609 3-idiots （FFT）

3-idiots

Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)

Total Submission(s): 4122    Accepted Submission(s): 1457

[align=left]Problem Description[/align]
King OMeGa catched three men who had been streaking in the street. Looking as idiots though, the three men insisted that it was a kind of performance art, and begged the king to free them. Out of hatred
to the real idiots, the king wanted to check if they were lying. The three men were sent to the king's forest, and each of them was asked to pick a branch one after another. If the three branches they bring back can form a triangle, their math ability would
save them. Otherwise, they would be sent into jail.

However, the three men were exactly idiots, and what they would do is only to pick the branches randomly. Certainly, they couldn't pick the same branch - but the one with the same length as another is available. Given the lengths of all branches in the forest,
determine the probability that they would be saved.
[align=left]Input[/align]
An integer T(T≤100) will exist in the first line of input, indicating the number of test cases.

Each test case begins with the number of branches N(3≤N≤105).

The following line contains N integers a_i (1≤a_i≤105), which denotes the length of each branch, respectively.
[align=left]Output[/align]
Output the probability that their branches can form a triangle, in accuracy of 7 decimal places.
[align=left]Sample Input[/align]

2
4
1 3 3 4
4
2 3 3 4

[align=left]Sample Output[/align]

0.5000000
1.0000000

[align=left]Source[/align]
2013 Multi-University Training Contest 1

[align=left]Recommend[/align]
liuyiding   |   We have carefully selected several similar problems for you:  5932 5931 5930 5929 5928 
题解：给你n条线段。问随机取三个，可以组成三角形的概率。
首先题目给了a数组，

如样例一：

4

1 3 3 4

把这个数组转化成num数组，num[i]表示长度为i的有num[i]条。

样例一就是

num = {0 1 0 2 1}

代表长度0的有0根，长度为1的有1根，长度为2的有0根，长度为3的有两根，长度为4的有1根。

使用FFT解决的问题就是num数组和num数组卷积。

num数组和num数组卷积的解决，其实就是从{1 3 3 4}取一个数，从{1 3 3 4}再取一个数，他们的和每个值各有多少个。

例如{0 1 0 2 1}*{0 1 0 2 1} 卷积的结果应该是{0 0 1 0 4 2 4 4 1 }

长度为n的数组和长度为m的数组卷积，结果是长度为n+m-1的数组。

{0 1 0 2 1}*{0 1 0 2 1} 卷积的结果应该是{0 0 1 0 4 2 4 4 1 }。

这个结果的意义如下：

从{1 3 3 4}取一个数，从{1 3 3 4}再取一个数

取两个数和为 2 的取法是一种：1+1。

和为 4 的取法有四种：1+3， 1+3 ，3+1 ，3+1。

和为 5 的取法有两种：1+4 ，4+1。

和为 6的取法有四种：3+3,3+3,3+3,3+3,3+3。

和为 7 的取法有四种： 3+4,3+4,4+3,4+3。

和为 8 的取法有 一种：4+4。

利用FFT可以快速求取循环卷积，具体求解过程不解释了，就是DFT和FFT的基本理论了。

总之FFT就是快速求到了num和num卷积的结果。只要长度满足>=n+m+1.那么就可以用循环卷积得到线性卷积了。

详细地可以看下面我的代码或者kuangbin博客

AC代码：

#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
typedef long long ll;
using namespace std;
const int N = 500005;
const double pi = acos(-1.0);

char s1
,s2
;
int len,res
;

struct Complex
{
double r,i;
Complex(double r=0,double i=0):r(r),i(i) {};
Complex operator+(const Complex &rhs)
{
return Complex(r + rhs.r,i + rhs.i);
}
Complex operator-(const Complex &rhs)
{
return Complex(r - rhs.r,i - rhs.i);
}
Complex operator*(const Complex &rhs)
{
return Complex(r*rhs.r - i*rhs.i,i*rhs.r + r*rhs.i);
}
} va
,vb
;

//雷德算法--倒位序
void rader(Complex F[],int len) //len = 2^M,reverse F[i] with  F[j] j为i二进制反转
{
int j = len >> 1;
for(int i = 1;i < len - 1;++i)
{
if(i < j) swap(F[i],F[j]);  // reverse
int k = len>>1;
while(j>=k)
{
j -= k;
k >>= 1;
}
if(j < k) j += k;
}
}
//FFT实现
void FFT(Complex F[],int len,int t)
{
rader(F,len);
for(int h=2;h<=len;h<<=1) //分治后计算长度为h的DFT
{
Complex wn(cos(-t*2*pi/h),sin(-t*2*pi/h)); //单位复根e^(2*PI/m)用欧拉公式展开
for(int j=0;j<len;j+=h)
{
Complex E(1,0); //旋转因子
for(int k=j;k<j+h/2;++k)
{
Complex u = F[k];
Complex v = E*F[k+h/2];
F[k] = u+v; //蝴蝶合并操作
F[k+h/2] = u-v;
E=E*wn; //更新旋转因子
}
}
}
if(t==-1)   //IDFT
for(int i=0;i<len;++i)
F[i].r/=len;
}
//求卷积
void Conv(Complex a[],int len)
{
FFT(a,len,1);
for(int i=0;i<len;++i) a[i] = a[i]*a[i];
FFT(a,len,-1);
}

int a
;
Complex F
;
ll num
,sum
;
int n;

void init()
{
memset(num,0,sizeof(num));
scanf("%d",&n);
for(int i=0; i<n; i++)
{
scanf("%d",&a[i]);
num[a[i]]++;
}
sort(a, a + n);

int len1 = a[n-1] + 1;
len  = 1;

while(len < len1*2) len <<= 1;

for(int i=0; i<len1; i++)
F[i] = Complex(num[i],0);

for(int i=len1; i<len; i++)
F[i] = Complex(0,0);
}

void gao()
{
Conv(F,len);

//num数组就是卷积后的结果，表示两两组合
for(int i=0; i<len; i++)
num[i] = (ll)(F[i].r+0.5);

len = a[n-1]*2;

//本身和本身组合是不行的,减掉取两个相同的组合
for(int i=0; i<n; i++)
num[a[i]+a[i]]--;

//选择的无序，再除以2
for(int i=1; i<=len; i++)
num[i] >>= 1;
sum[0] = 0;
//对num数组求前缀和
for(int i=1; i<=len; i++)
sum[i] = sum[i-1] + num[i];

ll cnt = 0;
for(int i=0; i<n; i++)
{
//长度和大于a[i]的取两个的取法
cnt+=sum[len]-sum[a[i]];

//减掉一个取大，一个取小的
cnt-=(ll)(n-1-i)*i;

//减掉一个取本身，另外一个取其它
cnt-=(n-1);

//减掉大于它的取两个的组合
cnt-=(ll)(n-1-i)*(n-i-2)/2;
}
ll tot = (ll)n*(n-1)*(n-2)/6;
printf("%.7lf\n",(double)cnt/tot);
}

int main()
{
int t;
scanf("%d",&t);
while(t--)
{
init();
gao();
}
return 0;
}