试除法整数分解 筛法整数分解 PollardRho大整数分解【模板】

试除法整数分解

int factor[11000];  //记录素因子个数
int ct; //记录每项素因子个数factor[0] = 2 表示第一个素因子2的个数为2
void Divide(int N)
{
    ct = 0;
    for(int i = 2; i <= sqrt(N*1.0); ++i)
    {
        while(N % i == 0)
        {
            factor[ct++] = i;
            N /= i;
        }
    }
    if(N != 1)
        factor[ct++] = N;
}

筛法整数分解

const int MAXN = 11000;
int Prime[MAXN],NPrime,ct;  //ct<span style="font-family: Arial, Helvetica, sans-serif;">记录每项素因子个数factor[0] = 2 表示第一个素因子2的个数为2</span>

//Prime[]存放素数，NPrime为素数个数，ct为素因子个数
bool IsPrime[MAXN];
int factor[11000];//存放素因子个数

void GetPrime()
{
    NPrime = 0;
    for(int i = 2; i <= MAXN; ++i)
        IsPrime[i] = 1;
    for(int i = 2; i <= sqrt(MAXN-1.0); ++i)
    {
        if(IsPrime[i])
        {
            Prime[NPrime++] = i;
            for(int j = i*i; j < MAXN; j+=i)
            {
                IsPrime[j] = 0;
            }
        }
    }
}

void Divide(int N)
{
    int temp = sqrt(N*1.0);
    ct = 0;
    for(int i = 0; i < NPrime; ++i)
    {
        if(Prime[i] > temp)
            break;
        while(N%Prime[i] == 0)
        {
            factor[ct++] = Prime[i];
            N /= Prime[i];
        }
    }
    if(N != 1)
        factor[ct++] = N;
}

PollardRho大整数分解

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<math.h>
#define MAX_VAL (pow(2.0,60))
//miller_rabbin素性测试
//__int64 mod_mul(__int64 x,__int64 y,__int64 mo)
//{
//    __int64 t;
//    x %= mo;
//    for(t = 0; y; x = (x<<1)%mo,y>>=1)
//        if(y & 1)
//            t = (t+x) %mo;
//
//    return t;
//}

__int64 mod_mul(__int64 x,__int64 y,__int64 mo) //x * y % mo
{
    __int64 t,T,a,b,c,d,e,f,g,h,v,ans;
    T = (__int64)(sqrt(double(mo)+0.5));
    t = T*T - mo;
    a = x / T;
    b = x % T;
    c = y / T;
    d = y % T;
    e = a*c / T;
    f = a*c % T;
    v = ((a*d+b*c)%mo + e*t) % mo;
    g = v / T;
    h = v % T;
    ans = (((f+g)*t%mo + b*d)% mo + h*T)%mo;
    while(ans < 0)
        ans += mo;
    return ans;
}
__int64 mod_exp(__int64 num,__int64 t,__int64 mo)   //num^t % mo
{
    __int64 ret = 1, temp = num % mo;
    for(; t; t >>=1,temp=mod_mul(temp,temp,mo))
        if(t & 1)
            ret = mod_mul(ret,temp,mo);

    return ret;
}

bool miller_rabbin(__int64 n)   //MillerRabbin素数测试
{
    if(n == 2)
        return true;
    if(n < 2 || !(n&1))
        return false;
    int t = 0;
    __int64 a,x,y,u = n-1;
    while((u & 1) == 0)
    {
        t++;
        u >>= 1;
    }
    for(int i = 0; i < 50; i++)
    {
        a = rand() % (n-1)+1;
        x = mod_exp(a,u,n);
        for(int j = 0; j < t; j++)
        {
            y = mod_mul(x,x,n);
            if(y == 1 && x != 1 && x != n-1)
                return false;
            x = y;
        }
        if(x != 1)
            return false;
    }
    return true;
}
//PollarRho大整数因子分解
__int64 minFactor;  //最小的素因子
__int64 gcd(__int64 a,__int64 b)
{
    if(b == 0)
        return a;
    return gcd(b, a % b);
}

__int64 PollarRho(__int64 n, int c)
{
    int i = 1;
    srand(time(NULL));
    __int64 x = rand() % n;
    __int64 y = x;
    int k = 2;
    while(true)
    {
        i++;
        x = (mod_exp(x,2,n) + c) % n;
        __int64 d = gcd(y-x,n);
        if(1 < d && d < n)
            return d;
        if(y == x)
            return n;
        if(i == k)
        {
            y = x;
            k *= 2;
        }
    }
}
int Ans[1100],cnt;//Ans来存放素因子，cut用来计数
void getSmallest(__int64 n, int c)  //拆分n
{
    if(n == 1)
        return;
    if(miller_rabbin(n))    //如果n为素数
    {
        if(n < minFactor)<span style="white-space:pre">    </span>//Ans[cnt++] = n;
            minFactor = n;
        return;
    }                       
    //n不为素数
    __int64 val = n;
    while(val == n) 
        val = PollarRho(n,c--); //得到约数val
    getSmallest(val,c);     //尝试拆分n的约束val
    getSmallest(n/val,c);   //尝试拆分n的另一个约数n/val
}