HDU - 4609 3-idiots （FFT）

最新推荐文章于 2022-04-06 16:04:01 发布
最新推荐文章于 2022-04-06 16:04:01 发布
阅读量230 收藏 1
点赞数
分类专栏： =====FFT=====
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/birdmanqin/article/details/110880726
版权
这篇博客介绍了如何使用快速傅里叶变换(FFT)来解决数学问题，特别是计算排列组合计数，并应用这些计数来求解求任选3个数能构成三角形的概率问题。通过排序、多项式乘法和容斥原理，博主给出了三种不同的实现方式，分别处理了重复计数和除以2的情况，最后得出概率结果。
摘要由CSDN通过智能技术生成

题链：https://vjudge.net/problem/HDU-4609

题意：n个数，求任选3个数组成三角形的概率。

思路：先排一下序，然后就变成求 ai+aj>ak (i<j<k)三元组的个数，和此题类似，将ai看作多项式的指数，num[ai]看作多项式的系数。FFT求多项式相乘，再计算答案，系数ai就是对应和为i的个数。首先要把自己加自己（ai+ai）的减去，然后再除于2（因为 ai+aj 和 aj+ai 都算了）。注意，我们要求的ai+aj>ak，ai和aj要小于ak。根据容斥原理，要减去一大一小，有自己本身，两个都大的情况。

代码1：

#include <bits/stdc++.h>
#define ll long long
using namespace std;
const int N = 1e5+10;
const int M = 9e4+10; 
const double PI = acos(-1.0);
struct Complex
{
    double r,i;
    Complex(double _r = 0,double _i = 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 change(Complex* y,int len)
{
    int i,j,k;
    for(i = 1, j = len/2;i < len-1;i++)
    {
        if(i < j)swap(y[i],y[j]);
        k = len/2;
        while( j >= k)
        {
            j -= k;
            k /= 2;
        }
        if(j < k)j += k;
    }
}
void fft(Complex* y,int len,int on)
{
    change(y,len);
    for(int h = 2;h <= len;h <<= 1)
    {
        Complex wn(cos(-on*2*PI/h),sin(-on*2*PI/h));
        for(int j = 0;j < len;j += h)
        {
            Complex w(1,0);
            for(int k = j;k < j+h/2;k++)
            {
                Complex u = y[k];
                Complex t = w*y[k+h/2];
                y[k] = u+t;
                y[k+h/2] = u-t;
                w = w*wn;
            }
        }
    }
    if(on == -1)
        for(int i = 0;i < len;i++)
            y[i].r /= len;
}
Complex x1[N<<2];
Complex x2[N<<2];
int n,m,a[N];
int num[N];
ll num1[N<<1],pre[N<<1]; 
int main(void){
	int t;
	scanf("%d",&t);
	while(t--){
		int maxa=0;
		scanf("%d",&n);
		memset(num,0,sizeof num);
		for(int i=1;i<=n;i++){
			scanf("%d",&a[i]);
			maxa=max(maxa,a[i]);
			num[a[i]]++;
		}
		sort(a+1,a+1+n);
		int len,len1;
		len1=maxa+1;
		len=1;
		while(len < 2 * len1) len <<= 1;
		for(int i = 0; i < len1; i++)
		   x1[i] = Complex(num[i],0);
		for(int i = len1; i < len; i++)
		   x1[i] = Complex(0,0);
		fft(x1,len,1);
		for(int i = 0;i < len;i++)
	            x1[i] = (x1[i]*x1[i]);
		fft(x1,len,-1);	
		maxa<<=1;
	    for(int i = 0;i <= maxa ;i++)
	        num1[i] = (long long)(x1[i].r+0.5);	
		for(int i=1;i<=n;i++)//ai+ai 
			num1[(a[i]<<1)]--;
		pre[0]=0;
		for(int i=1;i<= maxa ;i++){
			num1[i]>>=1;
			pre[i]=pre[i-1]+num1[i];
		}
		ll up=0;
		for(int i=1;i<=n;i++){
			up+=(pre[maxa]-pre[a[i]]);
			//一大一小 
			up-=1LL*(n-i)*(i-1);
			//自己本身 
			up-=(n-1);
			//两个都大 
			up-=1LL*(n-i)*(n-i-1)/2;
		}	
		ll down = 1LL*n*(n-1)*(n-2)/6;		
		printf("%.7f\n",1.0*up/down);	
	}
	
	return 0;	
}

代码2： 不事先除以2

#include <bits/stdc++.h>
#define ll long long
using namespace std;
const int N = 1e5+10;
const int M = 9e4+10; 
const double PI = acos(-1.0);
struct Complex
{
    double r,i;
    Complex(double _r = 0,double _i = 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 change(Complex* y,int len)
{
    int i,j,k;
    for(i = 1, j = len/2;i < len-1;i++)
    {
        if(i < j)swap(y[i],y[j]);
        k = len/2;
        while( j >= k)
        {
            j -= k;
            k /= 2;
        }
        if(j < k)j += k;
    }
}
void fft(Complex* y,int len,int on)
{
    change(y,len);
    for(int h = 2;h <= len;h <<= 1)
    {
        Complex wn(cos(-on*2*PI/h),sin(-on*2*PI/h));
        for(int j = 0;j < len;j += h)
        {
            Complex w(1,0);
            for(int k = j;k < j+h/2;k++)
            {
                Complex u = y[k];
                Complex t = w*y[k+h/2];
                y[k] = u+t;
                y[k+h/2] = u-t;
                w = w*wn;
            }
        }
    }
    if(on == -1)
        for(int i = 0;i < len;i++)
            y[i].r /= len;
}
Complex x1[N<<2];
Complex x2[N<<2];
int n,m,a[N];
int num[N];
long long num1[N<<1],pre[N<<1]; 
int main(void){
    int t;
    scanf("%d",&t);
    while(t--){
        int maxa=0;
        scanf("%d",&n);
        memset(num,0,sizeof num);
        for(int i=1;i<=n;i++){
            scanf("%d",&a[i]);
            maxa=max(maxa,a[i]);
            num[a[i]]++;
        }
        sort(a+1,a+1+n);
        int len,len1;
        len1=maxa+1;
        len=1;
        while(len < 2 * len1) len <<= 1;
        for(int i = 0; i < len1; i++)
           x1[i] = Complex(num[i],0);
        for(int i = len1; i < len; i++)
           x1[i] = Complex(0,0);
        fft(x1,len,1);
        for(int i = 0;i < len;i++)
                x1[i] = (x1[i]*x1[i]);
        fft(x1,len,-1);
		maxa<<=1;    
        for(int i = 0;i <= maxa ;i++)
            num1[i] = (long long)(x1[i].r+0.5);    
        for(int i=1;i<=n;i++)
            num1[(a[i]<<1)]--;
        pre[0]=0;
        for(int i=1;i<=maxa ;i++){
            pre[i]=pre[i-1]+num1[i];
        }
        ll up=0;
        for(int i=1;i<=n;i++){
            up+=pre[maxa]-pre[a[i]];
			//不除于2，要减去(i,1),(i,2),(i,3),...(i,i-1),(i,i+1),...,(i,n).注意 (i,i)已经事先减去了
						   //(i+1,1),(i+1,2),(i+1,3),...(i+1,i),(i+1,i+2),...,(i,n).注意 (i+1,i+1)已经事先减去了 
						   //         ...... 
						   //(n,1),(n,2),(n,3),...(n,i),...,(n,n-1).注意 (n,n)已经事先减去了 
			up-=1LL*(n-i+1)*(n-1);
			//不除于2，要减去(1,i),(1,i+1),(1,i+2),...(1,n).
						   //(2,i),(2,i+1),(2,i+2),...(2,n).
						   //         ...... 
						   //(i-1,i),(i-1,i+1),(i-1,i+2),...(i-1,n). 
            up-=1LL*(i-1)*(n-i+1);
        }    
        up/=2;//最后除以2 
        ll down =1LL*n*(n-1)*(n-2)/6;        
        printf("%.7f\n",1.0*up/down);    
    }
    
    return 0;    
}

代码3：除以2，另一种容斥方式

#include <bits/stdc++.h>
#define ll long long
using namespace std;
const int N = 1e5+10;
const int M = 9e4+10; 
const double PI = acos(-1.0);
struct Complex
{
    double r,i;
    Complex(double _r = 0,double _i = 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 change(Complex* y,int len)
{
    int i,j,k;
    for(i = 1, j = len/2;i < len-1;i++)
    {
        if(i < j)swap(y[i],y[j]);
        k = len/2;
        while( j >= k)
        {
            j -= k;
            k /= 2;
        }
        if(j < k)j += k;
    }
}
void fft(Complex* y,int len,int on)
{
    change(y,len);
    for(int h = 2;h <= len;h <<= 1)
    {
        Complex wn(cos(-on*2*PI/h),sin(-on*2*PI/h));
        for(int j = 0;j < len;j += h)
        {
            Complex w(1,0);
            for(int k = j;k < j+h/2;k++)
            {
                Complex u = y[k];
                Complex t = w*y[k+h/2];
                y[k] = u+t;
                y[k+h/2] = u-t;
                w = w*wn;
            }
        }
    }
    if(on == -1)
        for(int i = 0;i < len;i++)
            y[i].r /= len;
}
Complex x1[N<<2];
Complex x2[N<<2];
int n,m,a[N];
int num[N];
ll num1[N<<1],pre[N<<1]; 
int main(void){
	int t;
	scanf("%d",&t);
	while(t--){
		int maxa=0;
		scanf("%d",&n);
		memset(num,0,sizeof num);
		for(int i=1;i<=n;i++){
			scanf("%d",&a[i]);
			maxa=max(maxa,a[i]);
			num[a[i]]++;
		}
		sort(a+1,a+1+n);
		int len,len1;
		len1=maxa+1;
		len=1;
		while(len < 2 * len1) len <<= 1;
		for(int i = 0; i < len1; i++)
		   x1[i] = Complex(num[i],0);
		for(int i = len1; i < len; i++)
		   x1[i] = Complex(0,0);
		fft(x1,len,1);
		for(int i = 0;i < len;i++)
	            x1[i] = (x1[i]*x1[i]);
		fft(x1,len,-1);	
		maxa<<=1;
	    for(int i = 0;i <= maxa ;i++)
	        num1[i] = (long long)(x1[i].r+0.5);	
		for(int i=1;i<=n;i++)
			num1[(a[i]<<1)]--;
		pre[0]=0;
		for(int i=1;i<= maxa ;i++){
			num1[i]>>=1;
			pre[i]=pre[i-1]+num1[i];
		}
		ll up=0;
		for(int i=1;i<=n;i++){
			up+=(pre[maxa]-pre[a[i]]);
			//要减去(i,1),(i,2),(i,3),...(i,i-1),(i,i+1),...,(i,n).注意 (i,i)已经事先减去了
				  //(i+1,1),(i+1,2),(i+1,3),...(i+1,i),(i+1,i+2),...,(i,n).注意 (i+1,i+1)已经事先减去了 
				  //         ...... 
				  //(n,1),(n,2),(n,3),...(n,i),...,(n,n-1).注意 (n,n)已经事先减去了 					
			up-=1LL*(n-i+1)*(n-1);
			//多减了两个都大的情况,(i,i+1),(i+1,i)都减了 
			up+=1LL*(n-i+1)*(n-i)/2;
		}	
		ll down = 1LL*n*(n-1)*(n-2)/6;		
		printf("%.7f\n",1.0*up/down);	
	}
	
	return 0;	
}

 

Qingo呀
关注
专栏目录
HDU 4609 快速傅里叶变换
新熊君的博客
08-03 975
题目链接题意：已知n条边的长度，任取三条不同的边能够组成三角形的概率。很经典的FFT 如果已知任意两条边的和的情况，那么枚举第三条边可以在O(n)O(n)的复杂度下得出总方案数。难点便在于如果枚举两条边求和，其复杂度是不可承受的O(n2)O(n^2)考虑用FFT优化该过程。 构造多项式，xnx^n的系数是长度为n的边的条数。 类似于生成函数求方案数的思想。 该多项式与自身相乘便能得出任意两条
HDU-GO-crx插件
04-02
HDU-GO是一款专为杭州电子科技大学（HDU）学生设计的Chrome浏览器插件，它极大地简化了学生的选课流程并提供了多项实用功能。这款插件以中文简体界面呈现，便于国内用户使用，尤其对杭电的学生来说，是他们日常学习...
HDU 4609
BryantMark
07-29 672
实质上是两个多项式相乘注意去重 #include #include #include #include #include using namespace std; typedef long long LL; const double pi = acos(-1.0); const int maxn = 271111; const double eps = 1e-6; struct Com
HDU 4609 3-idiots（FFT）
weixin_34334744的博客
07-24 117
3-idiots Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)Total Submission(s): 216    Accepted Submission(s): 73 Problem Description King OMeGa catched three men ...
3-idiots HDU - 4609 （FFT +生成函数）
lalalafloat的博客
08-26 288
大致题意 给n条线段ai，询问不重复的选择3条（i!=j,i!=k,j!=k)线段，能凑成三角形 的概率是多少。（3<=n<=100000,1<=ai<=100000) 思路 和那道Triple Sums容斥的类似，先选择两个，A(x)*A(x)-B(x ^2)得到不重复选择两个数得到的各种数的方式，然后求一个前缀和sum[i]，然后考虑反过来求，求出不满足三角形的个数，枚...
HDU 4609 FFT
neweryyy的博客
04-06 473
题意 传送门 HDU 4609 3-idiots 题解 NNN 个数中任取三个，求选择的数可以作为三角形边长的概率。对于三角形的判定条件，即 ai+aj>ak,ak≥aj,aia_i+a_j>a_k, a_k\geq a_j,a_iai​+aj​>ak​,ak​≥aj​,ai​。计数时还需考虑所选择的数互不相同。 令 A(x)=∑xaiA(x)=\sum x^{a_i}A(x)=∑xai​，简单起见写为 ∑x\sum x∑x，根据容斥原理，考虑相同项的数量，可以得到 (∑x)2=∑x2+2
HDU-2000-2099.rar_hdu
09-19
这个名为"HDU-2000-2099.rar_hdu"的压缩包包含了该平台从2000到2099共100道题目的源代码。这些题目涵盖了初级到高级的各种算法，对于学习和提升编程技能非常有帮助。 首先，我们来看看这些题目可能涉及到的基础知识...
HDU-2000-2099.zip_hdu2000
09-23
【标题】"HDU-2000-2099.zip_hdu2000" 是一个包含杭电（Hangzhou Dianzi University）ACM竞赛题目解题报告的压缩包，覆盖了编号从2000到2099的题目。这个资源对于学习算法、提高编程技巧以及准备ACM/ICPC（国际大学...
HDU-EID-V2-核心板1
08-03
在本话题中，我们关注的是一个名为"HDU-EID-V2-核心板1"的特定设计，它涉及到STM32的核心组件、接口、电源管理和调试配置。 首先，核心板设计中提到了F103和F207两个型号的STM32芯片。F103和F207属于STM32的不同...
HDU-ACM_java.rar_hdu
09-22
【标题】"HDU-ACM_java.rar" 是一个针对杭州电子科技大学（HDU）ACM竞赛的资源压缩包，其中包含的是使用Java语言编写的算法解决方案。这个压缩包主要面向那些参与或准备参与ACM国际大学生程序设计竞赛（ICPC）的参赛...
HDU - 4609 3-idiots 计数问题
ACVevtor的博客
08-07 518
题目：给你n个长度的彼边，问你从中选出3条边能构成三角形的概率是多少。 思路： num[i]表示长度为i的边有多少条，然后用fft做卷积就能求出任意两条的组合情况，减去自己和自己的边，再除以2（因为一大一小算了2次），就是取2条边的组合情况了，然后枚举三角形最大的那条边，累加并去除不正确的种数 代码： #pragma comment(linker, "/STACK:1024000000,10
HDU--4609（FFT，计数）
dingdi3021的博客
07-28 148
2015-07-2801:56:55 【传送门】 题意：很短，给出最多10^5个数 L[1] ~ L[n]（数的范围：[1,10^5]），问任意挑选3个数以其为边长能组成三角形的概率。 思路：首先考虑三角形的判定：任意两边和大于第三边。对于10^5个数，两两求和显然不够快，但是我们可以这样：统计每个数的出现次数，然后把每个数看成m阶多项式的系数（m由数的最大值决定），就像：a0 ...
HDU 4609 3-idiots（组合数学+FFT）
ZSQ
03-04 1016
Description 给出n个木棍的长度ai，问从中任意选取三个木棍能组成一个三角形的概率 Input 第一行为一整数T表示用例组数，每组用例第一行为一整数n表示木棍数量，第二行n个整数ai表示每根木棍的长度(T<=100,3<=n<=10^5,1<=ai<=10^5) Output 对于每组用例，输出从n根木棍中随意选取三根木棍能组成三角形的概率 Sample Input 2 4
HDU - 4609 FFT
Bahuia的博客
03-20 438
题意： 给出n个长度，要求任意选择3个长度，能组成三角形的概率。 思路： 这也是一种常见的FFT题型，初看这个可能很难和FFT能解决的多项式联系到一起。 首先既然要组成三角形，一定要保证两边之和大于第三边，那么我们可以枚举一条边为x，然后看不超过x的两边之和一共有多少情况，这个很容易，只要求出来两边之和==0,1,..Max的种类数，然后用一个前缀和保存就行了。 现在关键是怎么对于任意一
HDU - 4609 3-idiots (FFT)
weixin_30721077的博客
03-09 105
题意：给你一堆线段的长度，求任选三条能组成三角形的概率。 解法：先求出任选两条能组成的所有长度及其数量，这个过程可以用FFT实现。设a[i]代表长度为i的线段的数量，数组b为数组a的平方，然后从b中减去每条线段自己的贡献，即b[i*2]-=a[i]，然后对所有的b[i]除以2，则b[i]就代表取两条线段长度和为i的方法数，剩下的用概率+前缀和搞一搞就行了。 1 #include<b...
hdu 4609（快速傅里叶变换）
北门的智慧
10-09 1574
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=4609； 题目大意：给出一些边长，问任取3边组成三角形的概率是多少。 分析：只要求出能组成三角形的有多少种再除以C(n,3)就好了。求得方法自然是用两最小边之和大于最长边。求和的部分可以用FFT优化。 代码如下： #include #include #include #include #
HDU - 4609 生成函数+FFT
青烟绕指柔的博客
01-17 1627
3-idiots Time Limit: 10000/5000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 10462 Accepted Submission(s): 3554 Problem Description King OMeGa catched three me...
HDU - 4609 3-idiots （FFT入门）
Lee_w_j__的博客
08-14 303
3-idiots Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 7656    Accepted Submission(s): 2672   Problem Description King OMeGa catched thre...
A - LOOPS HDU - 3853
最新发布
07-28
回答: 引用\[1\]和引用\[2\]是关于解决HDU - 3853问题的AC代码。这段代码使用了动态规划的思路，通过计算每个点的期望能量来解决问题。其中，f\[i\]\[j\]表示走到(i, j)这个点的期望能量。代码中还有一些特殊情况的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值