miller-rabin测素数与pollard-rho分解质因数

最新推荐文章于 2021-09-17 20:03:11 发布

gigo_64

最新推荐文章于 2021-09-17 20:03:11 发布

阅读量191

点赞数

分类专栏： ----------数论------------- 素数测试分解质因数

本文链接：https://blog.csdn.net/qq_42835815/article/details/102774783

版权

----------数论------------- 同时被 3 个专栏收录

36 篇文章 0 订阅

订阅专栏

分解质因数

3 篇文章 0 订阅

订阅专栏

素数测试

1 篇文章 0 订阅

订阅专栏

复健复健，，

两个随机化算法。

Miller-Rabin

判断一个数是否是质数。

费马小定理说： $a^{p-1}\equiv 1\mod p$

反过来定理是假的。

二次探测定理说：如果p是质数，且 $x^2\equiv 1\mod p$ ，则 $x\equiv 1\or \ p-1\mod p$

这个是真的，反过来也是真的。因为p不含有那两个约数。所以我们通过随机二次探测中的这个x，来检验。

不断地获得x的平方，如果之前不是1或者p-1，现在却是1了，那这个质数是假的。

如果最后不满足费马小定理，那这个质数也是假的。

每次随机获得正确答案的概率是 $\frac{1}{4}$ ，做个10次就差不多肯定有一次是对的。

如何获得x的平方呢，我们最后要得到费马小定理，所以将p-1分解为 $2^{a^k+b}$ 形式，然后rand一个x，先得到 $x^b$ ,然后不断自乘最后直到p-1。路上二次探测，复杂度logn。做十次也就加个常数。

建议：不适用rand的x，而是使用一个质数。

警告：如果使用vis来查较小的数的性质，注意vis[1]=1这个不能丢。

#include<bits/stdc++.h>
using namespace std;
#define in read()
#define int long long
#define ll long long
#define re register
int in{
	int cnt=0,f=1;char ch=0;
	while(!isdigit(ch)){
		ch=getchar();if(ch=='-')f=-1;
	}
	while(isdigit(ch)){
		cnt=cnt*10+ch-48;
		ch=getchar();if(ch=='-')f=-1;
	}
	return cnt*f;
}
const int N=2000003;
int prime[1000003],cnt,vis[N];
void prepare(){
	vis[1]=1;
	for(int i=2;i<=N;i++){
		if(!vis[i])prime[++cnt]=i;
		for(int j=1;j<=cnt&&prime[j]*i<=N;j++){
			vis[prime[j]*i]=1;
			if(i%prime[j]==0)break;
		}
	}
}int t;
int mul(int a,int b,int c){
	int sum=0;
	while(b){
		if(b&1)sum=(sum+a)%c;a=a*2%c;b>>=1; 
	}return sum;
}
int ksm(int a,int b,int c){
	int sum=1;
	while(b){
		if(b&1)sum=mul(sum,a,c);a=mul(a,a,c);b>>=1; 
	}return sum;
}
bool Miller(int n){
	if(n<=N-3)return !vis[n];
	if(!(n&1)||(n%3==0)||(n%5==0)||(n%7==0)||(n%61==0)||(n%24251==0))return false;
	int t=n-1,x=0;
	while(!(t&1))t>>=1,++x;
	for(int i=1;i<=7;i++){
		int d=prime[rand()%cnt+1];
		if(n%d==0)return false;
		d=ksm(d,t,n);int pre=d;
		for(int j=1;j<=x;j++){
			d=mul(d,d,n);
			if(d==1&&pre!=1&&pre!=n-1)return false;
			pre=d;
		}if(d!=1)return false;
	}return true;
}

signed main(){
	srand(time(0));
	t=in;t=in;prepare();
	while(t--){
		int x=in;
		if(Miller(x))cout<<"Yes"<<'\n';else cout<<"No"<<'\n';
	}
	return 0;
}

pollard-rho

我们用随机化算法拆解一个数的因数，目的是随机一个x|n。

然而这样随机到x的概率太小了，所以我们随机k个x，只要有一对满足 $abs(x_i-x_j)|n$ 即可。

然而为了达到较高的期望，要选大概 $n^{\frac{1}{4}}$ 个数，这可能存不下，所以我们通过随机x_i和x_j来进行判断。

我们不能仅仅通过rand来生成，这概率也很小。通过一个神奇的函数可以尽量美好地生成，就是 $f(x)=x^2+c\mod n$ 。我们每次只需要rand这个c就可以。

然而一直这样跳下去是会出现循环的，出现循环意味着这个c已经失效了。怎么判定这个循环呢？

方法1：floyd判环

如果两个人在操场上同向走，一个人是另一个人速度的两倍，则两个人相遇时，快的那个人至少多走了一圈。

我们每次令x=f(x),y=f(f(x))。这样就得到了两个数x_i和x_{2i}。如此走下去，如果是1，就下一个，如果是n，说明x-y=0,出环了，换c。如果都不是，说明找到因数了。

int pollard(n){
	int x=2,y=2,d=1,a=rand()%n;
	while(d==1){
		x=(x*x+a)%n;y=(y*y+a)%n;y=(y*y+a)%n;
		d=gcd(abs(x-y),n);
	}if(d==n)return -1;
	return d;
}

方法2：brent判环法

不每次更新y，而是在x_i这个i成为2的方幂的时候，更新y=x，反之只更新x。

bool pollard(n){
	int x=2,y=2,i=2,k=1,d=1,a=rand()%n;
	while(d){
		++k;
		x=(x*x+a)%n;
		d=gcd(abs(x-y),n);
		if(i==k)i<<=1,y=x;
	}if(d==n)return -1;
	return d;
}

对brent的优化

我们发现，这个算法的复杂度本质来源是gcd的使用次数。我们尽量减少这个函数的调用。

在这种倍增的背景下，每一段中，只要有一个gcd>1，就说明可以了。

那我们大可以把每次得到的gcd乘起来，最后判一次。

这样复杂度期望是原来的根号。

同时从zxyoi处学得，特判这个数为2,3,5,7,61,24251，可以去除一大堆可能值，大大加快速度，可以卡过洛谷的数据，你就可以水一道黑题。

当然，注意卡常。动用你的聪明才智，%操作是否等于0可以转化为先/再*看是否相等，维护maxpri来快速得到小数据的最大质因数。

最重要的一点：mul这个地方要改一个快速乘。大体就是将a*b先转double的a/mod*b然后转回整型再乘mod。反正不这样干要T十多个点，，。

#include<bits/stdc++.h>
using namespace std;
#define in read()
#define re register
#define il inline
#define int long long
int ans;
int in{
	int cnt=0,f=1;char ch=0;
	while(!isdigit(ch)){
		ch=getchar();if(ch=='-')f=-1;
	}
	while(isdigit(ch)){
		cnt=cnt*10+ch-48;ch=getchar();
	}return cnt*f;
}
const int N=2000003;
int prime[N>>1],vis[N],cnt,maxpri[N];
void prepare(){
	vis[1]=1;
	for(int i=2;i<=N;i++){
		if(!vis[i]){
			prime[++cnt]=i;maxpri[i]=i;
		}
		for(int j=1;j<=cnt&&prime[j]*i<=N;j++){
			vis[prime[j]*i]=1;maxpri[prime[j]*i]=maxpri[i];
			if(i==i/prime[j]*prime[j])break;
		}
	}
}
int mul(int a,int b,int c){
	return (a*b-(int)((long double)a/c*b)*c+c)%c; 
}
int gcd(int a,int b){
	if(!b||!a)return a+b;
	return gcd(b,a%b);
}
int ksm(int a,int b,int c){
	int sum=1;
	while(b){
		if(b&1)sum=mul(sum,a,c);b>>=1;a=mul(a,a,c);
	}return sum;
}
bool isprime(int n){
	if(n<=N-3)return !vis[n];
	if(!(n&1)||n/2*2==n||n/3*3==n||n/5*5==n||n/7*7==n||n/61*61==n||n/24251*24251==n)return false;
	int x=n-1,d=0;
	while(!(x&1))x>>=1,++d;
	for(int i=1;i<=7;i++){
		int gu=prime[rand()%cnt+1];
		if(n/gu*gu==n)return false;
		gu=ksm(gu,x,n);int pre=gu;
		for(int j=1;j<=d;j++){
			gu=mul(gu,gu,n);
			if(gu==1&&pre!=1&&pre!=n-1)return false;
			pre=gu;
		}if(gu!=1)return false;
	}return true;
}
int pollard(int n){
	if(!(n&1))return 2;
	if(n/3*3==0)return 3;
	if(n/5*5==0)return 5;
	if(n/7*7==0)return 7;
	if(n/61*61==0)return 61;
	if(n/24251*24251==0)return 24251;
	int x=0,y=0,d=1,q=1,c=rand()%(n-1)+1;
	for(int k=1;;k<<=1,y=x,q=1){
		for(int i=1;i<=k;i++){
			x=(mul(x,x,n)+c)%n;
			q=mul(q,abs(x-y),n);
		}
		d=gcd(q,n);if(d>1)return d;
	}
}
void Break(int n){
	if(n==1||n<=ans)return;
	if(isprime(n))return (void)(ans=max(ans,n));
	if(n<=N-3)return (void)(ans=max(ans,maxpri[n]));
	int x=n;
	while(x==n){
		x=pollard(x);
	}
	Break(x);
	while(n/x*x==n)n/=x;
	Break(n);
}
signed main(){
	srand(time(0));
	prepare();int t=in;
	while(t--){
		int n=in;
		if(n<=N-3){
			if(vis[n])printf("%lld\n",maxpri[n]);else printf("Prime\n");
		}
		else{
			ans=0;
			Break(n);
			if(ans==n)printf("Prime\n");else printf("%lld\n",ans);
		}
		
	}
	return 0;
}

gigo_64

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
miller-rabin测素数与pollard-rho分解质因数

复健复健，，两个随机化算法。Miller-Rabin判断一个数是否是质数。费马小定理说：反过来定理是假的。二次探测定理说：如果p是质数，且，则这个是真的，反过来也是真的。因为p不含有那两个约数。所以我们通过随机二次探测中的这个x，来检验。不断地获得x的平方，如果之前不是1或者p-1，现在却是1了，那这个质数是假的。如果最后不满足费马小定理，那这个质数也是假的。...
复制链接

扫一扫