环境 : 给定一个数n,让你把它分解成多个素数的乘积

你离此算法大成就差一个Miller-Rabin素数检测算法和floyd判圈算法了

Pollard Rho算法:

对于一个数n,只需要如下步骤即可分成若干个素数

1. 找到一个数p , 使p|n
2. 那么n就可以变成p和n/p
3. 如果p或者n/p不是质数,当成n重新第一步

判断是否为质数用Miller-Rabin素数检测算法

最关键的是如何找到这个数p

因为随机产生p可以一直找不到,所以我们要用下面的方法,用两个数的差代替p

1. 随机产生一个数p1,和一个随机常数c
2. 令p2=(p1^2+c)%n
3. 如果|p2-p1|可以被n整除,说明已经找到
4. 如果找不到,令p1=p2继续第一步

p->(p^2+c)%n,这样基本是不会出现p变回这前的数从而进行循环的情况,且一直重复的话,|(p^2+c)%n-p|也基本不会重复

怎么判断循环?如果用数组和map显然是不行的,空间肯定会炸

那么就需要floyd判环这种空间复杂度为O(1)的方法了

因为循环节可能是走着走着才出现的,就像希腊字母 $\rho$(rho) ,所以此法名为Pollard Rho

$\\ $

代码:

#include<bits/stdc++.h>

using namespace std;

typedef long long LL;
typedef long long ll;

ll ModMul(ll a,ll b,ll n)//快速积取模 a*b%n
{
    ll ans=0;
    while(b)
    {
        if(b&1)
            ans=(ans+a)%n;
        a=(a+a)%n;
        b>>=1;
    }
    return ans;
}
ll ModExp(ll a,ll b,ll n)//快速幂取模 a^b%n
{
    ll ans=1;
    while(b)
    {
        if(b&1)
            ans=ModMul(ans,a,n);
        a=ModMul(a,a,n);
        b>>=1;
    }
    return ans;
}
bool Miller_Rabin(ll n)//Miller-Rabin素数检测算法
{
      ll i,j,a,x,y,t,u,s=10;
      if(n==2)
            return true;
      if(n<2||!(n&1))
            return false;
      for(t=0,u=n-1;!(u&1);t++,u>>=1);//n-1=u*2^t
      for(i=0;i<s;i++)
      {
          a=rand()%(n-1)+1;
          x=ModExp(a,u,n);
          for(j=0;j<t;j++)
          {
              y=ModMul(x,x,n);
              if(y==1&&x!=1&&x!=n-1)
                    return false;
              x=y;
          }
          if(x!=1)
                return false;
      }
      return true;
}


LL Pollard_Rho(LL n,LL c)
{
    LL i=1,j=2,x=rand()%(n-1)+1,y=x;//随机初始化一个基数（p1）
    while(1)
    {
        i++;
        x=(ModMul(x,x,n)+c)%n;//玄学递推
        LL p=__gcd((y-x+n)%n,n);
        if(p!=1&&p!=n)return p;//判断
        if(y==x)return n;//y为x的备份，相等则说明遇到圈，退出
        if(i==j)
        {
            y=x;
            j<<=1;
        }//更新y，判圈算法应用
    }
}
void find(LL n,LL c)//同上，n为待分解数，c为随机常数
{
    if(n==1)return;
    if(Miller_Rabin(n))//n为质数
    {
        //保存，根据不同题意有不同写法，在此略去
        //printf("%lld\n",n);
        return;
    }
    LL x=n,k=c;
    while(x==n)x=Pollard_Rho(x,c++);//当未分解成功时，换个c带入算法
    find(n/x,k);
    find(x,k);
    //递归操作
}


int main(){
    LL c=1;
    //for(LL i=1000000008;i;i++)if(Miller_Rabin(i)){printf("%lld\n",i);break; }
    LL n=1000000009 ;n*= 1000000007;
    printf("%lld\n",n);
    find(n,1);
    printf("%.3fs\n",(double)clock()/CLOCKS_PER_SEC);//1ms

}

上限数据测试 :

(1e6+3)(1e6+33)(1e6+37),运行时间12ms
(1e9+7)(1e9+9),运行时间为180ms

对于因子少且大的时候,该方法依然不是很有效

比赛时2000ms如果数据范围为1e18的话,你只能跑10组数。。。