Pollard-Rho 算法

Pollard-Rho

一种复杂度大概在 $ O(n^{\frac 1 4} \log n) $ 的分解质因数方法。

Miller-Rabin

给定一个 $ 10^{18} $ 范围的数,判断质数

由于费马小定理,我们知道当 $ a\bmod p \neq 0 $ 且 $ p $ 为 质数 时,$ a^{p-1} \equiv 1 \pmod p $ ,而如果 $ p $ 不为质数,这东西有一定几率成立。

所以我们有一个想法,随机一些 $ a $ ,对每个 $ a $ 用这个式子判断一下,如果有一个错误了它就直接是合数了。

但是有些合数更特殊,对于 $ 1\leq a < p $ 都成立这个式子,比如 $ 561 $ 。

于是有了个二次探测定理。如果 $ x^2 \equiv 1 \pmod p $ 则有 $ x\equiv \pm 1 \pmod p $ ,其中 $ p $ 为质数。

证明很显然, $ p | x^2 - 1 \to p | (x+1)(x-1) $ ,所以 $ p | (x+1) $ 或 $ p | (x-1) $。

然而仍然,对于合数这个东西有一定几率不成立。

这个算法的做法就是,检测 $ a^{p-1} $ 模 $ p $ 下的值,如果不是 1 或者 -1 那么必然不是合数。如果算出来是 1 并且 $ 2 | \frac{p-1} 2 $ ,那么递归下去算 $ \frac{p-1} 2 $ ,如果算出来是 $ p-1 $ 直接返回为质数。

这样做并不是一定正确的,所以我们得多拿几个 $ a $ 来测。

复杂度是 $ O(k\log^2 n) $ 的。

具体而言:

  • $ n \leq 4\times 10^9 $ 时, $ 2,7,61 $ 即可保证正确
  • $ n \leq 10^{18} $ 时,$ 2,3,5,7,11,13,17,19,23 $ 可以保证正确
  • $ n \leq 10^{19} $ 时,$ 2,3,5,7,11,13,17,19,23,29,31,37 $ 可以保证正确。

虽然多数时候这个复杂度不会成为瓶颈,但是它仍然可以被优化。可以预处理出 $ p - 1 $ 的分解中 2 的个数 $ k $ 然后先算出 $ a{\frac{p-1}{2k}} $ 再一步步平方回去,这样复杂度就可以优化掉 ksm 变成 $ O(k\log n) $

Pollard-Rho

现在已经完全明白了如何判质数,那么怎么质因数分解呢?

首先用 Miller-Rabin 判一下它是不是质数,是就直接 return 了。

否则,它一定有一个 $ \leq \sqrt n $ 的因子 $ p $

于是有一个乱搞思路,随机选出 $ n^{\frac 1 4} $ 个数,两两做差再求 gcd ,期望情况下可以分解出来,但是这样并不优秀。

所以考虑设函数 $ f(i) = (f(i-1)^2 + a) \pmod n $ 。其中 $ a $ 是一个常数。我们发现,这样的话 $ f $ 必然会循环。它最后的形状很类似一个 $ \rho $ ,先经历尾巴再进入一个循环。(同时这也是为啥名字叫 Pollard-Rho)。

显然,即使是在$ \bmod p $ 的意义下它仍然是循环的,我们可以认为这个 函数 的数字出现是随机的,所以 $ \bmod p $ 意义下的最终环的长度是 $ O(p^\frac 1 2) = O(n^ \frac 1 4) $ 的。

具体应该怎么做呢? Pollard-Rho 有两种实现方法:

  • Floyd 判环

    一种比较好写好理解的方法,但是貌似不如第二种优秀。

    做法是,每次让 $ s $ 走一步,$ t $ 走两步,然后求一下 $ y-x $ 和 $ n $ 的 $ \gcd $ 。但是如果 $ x = y $ 了就说明进入了 $ \bmod n $ 的循环,就挂掉了,分解失败,需要再次随机继续来。

    如果我们可以在某一时刻发现 $ \gcd(y-x , n) \neq 1 $ 这就意味着我们找到了一个 $\bmod p $ 意义下的环,并且没有找到 $ \bmod n $ 意义下的环。成功进行了一次分解!

好现在可以总结一下,Pollard-Rho 的本质是在环上跑,目的是在进入 $ \bmod n $ 的环之前进入 $ \bmod p $ 的环。如果做到了,那就可以分解出最小质因数 $ p $ 的某个倍数(并且也是 $ n $ 的约数),否则(比如同时进入这两个环)就需要调参重来。

然后是一种更优秀的判环方法:

  • Brent 判环

    每次 $ x $ 走一步,当它走了 $ 2^k $ 时让 $ y = x $,然后 $ x $ 继续走。同时在 $ x $ 走了 $ 128 $ 的倍数步的时候,我们 check 一次。

    我也不知道为啥 \(128\) 这个数字很优秀,但是这样做确实很优秀。

#include "iostream"
#include "algorithm"
#include "cstring"
#include "cstdio"
#include "cmath"
#include "vector"
using namespace std;
typedef long long ll;

ll mul( ll a , ll b , ll md ) {
    return ( a * b - (ll)( (long double)a / md * b + 0.5 ) * md + md ) % md;
}
ll Pow( ll x , ll a , ll md ) {
    ll cur = x % md , ans = 1;
    while( a ) {
        if( a & 1 ) ans = mul( ans , cur , md );
        cur = mul( cur , cur , md ) , a >>= 1;
    }
    return ans;
}

const int ck[] = {2,3,5,7,11,13,17,19,23} , _l = 8;
bool miller( ll n ) {
    if( n == 1 ) return false;
    ll t = n - 1; int cn = 0;
    while( !( t & 1 ) ) t >>= 1 , ++ cn;
    for( int i = 0 ; i < _l ; ++ i ) {
        if( n == ck[i] ) return true;
        ll a = Pow( ck[i] , t , n ) , nex = a;
        for( int j = 1 ; j <= cn ; ++ j ) {
            nex = mul( a , a , n );
            if( nex == 1 && a != 1 && a != n - 1 ) return false;
            a = nex;
        }
        if( a != 1 ) return false;
    }
    return true;
}

inline ll f( ll x , ll c , ll md ) {
    return ( mul( x , x , md ) + c ) % md;
}

inline ll _rand(  ) {
    return (ll) rand() << 32 | rand();
}
inline ll _randw() {
    return (ll)rand() << 48 | (ll)rand() << 32 | rand() << 16 | rand();
}
inline ll _abs( ll x ) {
    return x > 0 ? x : -x;
}
inline ll gcd( ll a , ll b ) {
    return !b ? a : gcd( b , a % b );
}

inline ll pollard_rho( ll n ) {
    ll s = 0 , t = 0 , c = _rand() % ( n - 1 ) + 1 , val = 1;
    for( int cir = 1 ; ; cir <<= 1 , s = t , val = 1 ) {
        for( int i = 0 ; i < cir ; ++ i ) {
            t = f( t , c , n ) , val = mul( val , _abs( t - s ) , n );
            if( i % 127 == 0 ) {
                ll g = gcd( val , n );
                if( g != 1 ) return g;
            }
        }
        ll g = gcd( val , n );
        if( g != 1 ) return g;
    }
}

vector<ll> divs;
inline void analyze( ll n ) {
    if( n == 1 ) return;
    if( miller( n ) ) { divs.push_back( n ); return; }
    ll d = n;
    while( d == n ) d = pollard_rho( n );
    n /= d;
    analyze( n ) , analyze( d );
}

int main() {
    srand( time(0) );
    int T;cin >> T;
    ll n;
    while( T-- ) {
        scanf("%lld",&n);
        if( miller( n ) ) { puts("Prime"); continue; }
        divs.clear();
        analyze( n );
        printf("%lld\n",*max_element( divs.begin() , divs.end() ) );
    }
}
posted @ 2020-02-29 18:23  yijan  阅读(275)  评论(0编辑  收藏  举报