任何人都可以帮我解决pollard rho的问题吗?我已经在C中实现了这个。它适用于最多10位数的数字,但是它无法处理更多的数字。
请帮助我改进它,以实现最多18位数字的分解。我的代码是this:
#include<stdio.h>
#include<math.h>
int gcd(int a, int b)
{
if(b==0) return a ;
else
return(gcd(b,a%b)) ;
}
long long int mod(long long int a , long long int b , long long int n )
{
long long int x=1 , y=a ;
while(b>0)
{
if(b%2==1) x = ((x%n)*(y%n))%n ;
y = ((y%n)*(y%n))%n ;
b/=2 ;
}
return x%n ;
}
int isprimes(long long int u)
{
if(u==3)
return 1 ;
int a = 2 , i ;
long long int k , t = 0 , r , p ;
k = u-1 ;
while(k%2==0)
{ k/=2 ; t++ ; }
while(a<=3) /*der are no strong pseudoprimes common in base 2 and base 3*/
{
r = mod(a,k,u) ;
for(i = 1 ; i<=t ; i++)
{
p = ((r%u)*(r%u))%u ;
if((p==1)&&(r!=1)&&(r!=(u-1)))
{ return 0 ; }
r = p ;
}
if(p!=1)
return 0 ;
else
a++ ;
}
if(a==4)
return 1 ;
}
long long int pol(long long int u)
{
long long int x = 2 , k , i , a , y , c , s;
int d = 1 ;
k = 2 ;
i = 1 ;
y = x ;
a = u ;
if(isprimes(u)==1)
{
return 1;
}
c=-1 ;
s = 2 ;
while(1)
{
i++;
x=((x%u)*(x%u)-1)% u ;
d = gcd(abs(y-x),u) ;
if(d!=1&&d!=u)
{ printf("%d ",d);
while(a%d==0) { a=a/d; }
x = 2 ;
k = 2 ;
i = 1 ;
y = x ;
if(a==1)
{ return 0 ; }
if(isprimes(a)!=0)
{ return a ; }
u=a ;
}
if(i==k)
{y = x ; k*=2 ; c = x ;} /*floyd cycle detection*/
if(c==x)
{ x = ++s ; }
}
return ;
}
int main()
{
long long int t ;
long long int i , n , j , k , a , b , u ;
while(scanf("%lld",&n)&&n!=0)
{ u = n ; k = 0 ;
while(u%2==0)
{ u/=2 ; k = 1 ; }
if(k==1) printf("2 ") ;
if(u!=1)
t = pol(u) ;
if(u!=1)
{
if(t==1)
{ printf("%lld",u) ; }
else
if(t!=0)
{ printf("%lld",t) ; }
}
printf("\n");
}
return 0;
}
抱歉长代码......我是一名新编码员。
答案 0 :(得分:4)
如果您将两个数字乘以m
模数,则中间产品可能会变得接近m^2
。因此,如果使用64位无符号整数类型,则它可以处理的最大模数为2^32
,如果模数较大,则可能发生溢出。当模量仅稍微大一点时很少见,但这只是不那么明显,如果模数允许溢出的可能性,你不能依靠幸运。
如果您选择最多m
绝对值的模m/2
的余数类或相当于等价物的代表,则可以获得更大的范围两倍:
uint64_t mod_mul(uint64_t x, uint64_t y, uint64_t m)
{
int neg = 0;
// if x is too large, choose m-x and note that we need one negation for that at the end
if (x > m/2) {
x = m - x;
neg = !neg;
}
// if y is too large, choose m-y and note that we need one negation for that at the end
if (y > m/2) {
y = m - y;
neg = !neg;
}
uint64_t prod = (x * y) % m;
// if we had negated _one_ factor, and the product isn't 0 (mod m), negate
if (neg && prod) {
prod = m - prod;
}
return prod;
}
因此,允许64位无符号类型的模数最多为2^33
。不是一大步。
该问题的推荐解决方案是使用大整数库,例如GMP在大多数(如果不是所有)Linux发行版上都可用作分发包,并且(相对)可以在Windows上轻松安装。
如果那不是一个选项(真的,你确定吗?),你可以使用俄罗斯农民乘法使其适用于更大的模数(对于无符号的64位整数类型最多2^63
): / p>
x * y = 2 * (x * (y/2)) + (x * (y % 2))
因此,对于计算,您只需要2*(m-1)
不会溢出。
uint64_t mod_mult(uint64_t x, uint64_t y, uint64_t m)
{
if (y == 0) return 0;
if (y == 1) return x % m;
uint64_t temp = mod_mult(x,y/2,m);
temp = (2*temp) % m;
if (y % 2 == 1) {
temp = (temp + x) % m;
}
return temp;
}
但请注意,此算法需要O(log y)步骤,因此在实践中它相当慢。对于较小的m
,您可以加快速度,如果2^k*(m-1)
没有溢出,您可以按k
位而不是单位(x*y = ((x * (y >> k)) << k) + (x * (y & ((1 << k)-1)))
)继续进行,这是如果你的模数永远不会大于48或56位,那么这是一个很好的改进。
使用模块化乘法的变体,您的算法将适用于更大的数字(但它会明显变慢)。您还可以尝试测试模数和/或因子的大小,以确定使用哪种方法,如果m < 2^32
或x < (2^64-1)/y
,简单(x * y) % m
将会这样做。