PollardRho大整数分解

最新推荐文章于 2024-02-16 20:53:03 发布
最新推荐文章于 2024-02-16 20:53:03 发布
阅读量7.1k 收藏 3
点赞数 4
CC 4.0 BY-SA版权
分类专栏： 数论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/acdreamers/article/details/8055189
本文通过几个具体的编程竞赛题目，详细介绍了素因子分解算法及其在解决特定数学问题中的应用，包括大数分解、求解互素子集等问题。

模版：

#include <iostream>
#include <stdlib.h>
#include <string.h>
#include <algorithm>
#include <stdio.h>

const int Times = 10;
const int N = 5500;

using namespace std;
typedef long long LL;

LL ct, cnt;
LL fac[N], num[N];

LL gcd(LL a, LL b)
{
    return b? gcd(b, a % b) : a;
}

LL multi(LL a, LL b, LL m)
{
    LL ans = 0;
    a %= m;
    while(b)
    {
        if(b & 1)
        {
            ans = (ans + a) % m;
            b--;
        }
        b >>= 1;
        a = (a + a) % m;
    }
    return ans;
}

LL quick_mod(LL a, LL b, LL m)
{
    LL ans = 1;
    a %= m;
    while(b)
    {
        if(b & 1)
        {
            ans = multi(ans, a, m);
            b--;
        }
        b >>= 1;
        a = multi(a, a, m);
    }
    return ans;
}

bool Miller_Rabin(LL n)
{
    if(n == 2) return true;
    if(n < 2 || !(n & 1)) return false;
    LL m = n - 1;
    int k = 0;
    while((m & 1) == 0)
    {
        k++;
        m >>= 1;
    }
    for(int i=0; i<Times; i++)
    {
        LL a = rand() % (n - 1) + 1;
        LL x = quick_mod(a, m, n);
        LL y = 0;
        for(int j=0; j<k; j++)
        {
            y = multi(x, x, n);
            if(y == 1 && x != 1 && x != n - 1) return false;
            x = y;
        }
        if(y != 1) return false;
    }
    return true;
}

LL pollard_rho(LL n, LL c)
{
    LL i = 1, k = 2;
    LL x = rand() % (n - 1) + 1;
    LL y = x;
    while(true)
    {
        i++;
        x = (multi(x, x, n) + c) % n;
        LL d = gcd((y - x + n) % n, n);
        if(1 < d && d < n) return d;
        if(y == x) return n;
        if(i == k)
        {
            y = x;
            k <<= 1;
        }
    }
}

void find(LL n, int c)
{
    if(n == 1) return;
    if(Miller_Rabin(n))
    {
        fac[ct++] = n;
        return ;
    }
    LL p = n;
    LL k = c;
    while(p >= n) p = pollard_rho(p, c--);
    find(p, k);
    find(n / p, k);
}

int main()
{
    LL n;
    while(cin>>n)
    {
        ct = 0;
        find(n, 120);
        sort(fac, fac + ct);
        num[0] = 1;
        int k = 1;
        for(int i=1; i<ct; i++)
        {
            if(fac[i] == fac[i-1])
                ++num[k-1];
            else
            {
                num[k] = 1;
                fac[k++] = fac[i];
            }
        }
        cnt = k;
        for(int i=0; i<cnt; i++)
            cout<<fac[i]<<"^"<<num[i]<<" ";
        cout<<endl;
    }
    return 0;
}

 

题目：http://poj.org/problem?id=2429

 

题意：给出两个数和，找出两个数和，使它们的最大公约数为，最小公倍数为，如果存在

     多个，则输出最小的那个。

 

分析：我们可以知道如果把分为两部分，那么每部分应分别存在于和之中，所以就是一个找

     因子的问题，这个由于数据范围太大，用pollard-rho大数分解即可，然后用dfs找因子。

 

#include <iostream>
#include <string.h>
#include <algorithm>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

using namespace std;
typedef unsigned long long LL;

const int Times = 10;
const LL INF = (LL)1<<61;
const int N = 550;

LL n, m, ct, cnt;
LL mini, mina, minb, ans;
LL fac[N], num[N];

LL gcd(LL a, LL b)
{
    return b? gcd(b, a % b) : a;
}

LL multi(LL a, LL b, LL m)
{
    LL ans = 0;
    a %= m;
    while(b)
    {
        if(b & 1)
        {
            ans = (ans + a) % m;
            b--;
        }
        b >>= 1;
        a = (a + a) % m;
    }
    return ans;
}

LL quick_mod(LL a, LL b, LL m)
{
    LL ans = 1;
    a %= m;
    while(b)
    {
        if(b & 1)
        {
            ans = multi(ans, a, m);
            b--;
        }
        b >>= 1;
        a = multi(a, a, m);
    }
    return ans;
}

bool Miller_Rabin(LL n)
{
    if(n == 2) return true;
    if(n < 2 || !(n & 1)) return false;
    LL m = n - 1;
    int k = 0;
    while((m & 1) == 0)
    {
        k++;
        m >>= 1;
    }
    for(int i=0; i<Times; i++)
    {
        LL a = rand() % (n - 1) + 1;
        LL x = quick_mod(a, m, n);
        LL y = 0;
        for(int j=0; j<k; j++)
        {
            y = multi(x, x, n);
            if(y == 1 && x != 1 && x != n - 1) return false;
            x = y;
        }
        if(y != 1) return false;
    }
    return true;
}

LL pollard_rho(LL n, LL c)
{
    LL i = 1, k = 2;
    LL x = rand() % (n - 1) + 1;
    LL y = x;
    while(true)
    {
        i++;
        x = (multi(x, x, n) + c) % n;
        LL d = gcd((y - x + n) % n, n);
        if(1 < d && d < n) return d;
        if(y == x) return n;
        if(i == k)
        {
            y = x;
            k <<= 1;
        }
    }
}

void find(LL n, int c)
{
    if(n == 1) return;
    if(Miller_Rabin(n))
    {
        fac[ct++] = n;
        return ;
    }
    LL p = n;
    LL k = c;
    while(p >= n) p = pollard_rho(p, c--);
    find(p, k);
    find(n / p, k);
}

void dfs(LL dept, LL product = 1)
{
    if(dept == cnt)
    {
        LL a = product;
        LL b = ans / a;
        if(gcd(a, b) == 1)
        {
            a *= n;
            b *= n;
            if(a + b < mini)
            {
                mini = a + b;
                mina = a;
                minb = b;
            }
        }
        return ;
    }
    for(int i=0; i<=num[dept]; i++)
    {
        if(product > mini) return;
        dfs(dept + 1, product);
        product *= fac[dept];
    }
}

int main()
{
    while(~scanf("%llu %llu", &n, &m))
    {
        if(n == m)
        {
            printf("%llu %llu\n",n,m);
            continue;
        }
        mini = INF;
        ct = cnt = 0;
        ans = m / n;
        find(ans, 120);
        sort(fac, fac + ct);
        num[0] = 1;
        int k = 1;
        for(int i=1; i<ct; i++)
        {
            if(fac[i] == fac[i-1])
                ++num[k-1];
            else
            {
                num[k] = 1;
                fac[k++] = fac[i];
            }
        }
        cnt = k;
        dfs(0, 1);
        if(mina > minb) swap(mina, minb);
        printf("%llu %llu\n",mina, minb);
    }
    return 0;
}


 

题目：http://acm.hdu.edu.cn/showproblem.php?pid=4344

 

题意：给一个数，求这个数的所有因子中组成的最大的一个子集，其中1和它本身除外，使得在这个子集中元素两两

     互素，求最大子集的元素个数，并且求出和最大的值。

 

分析：直接素因子分解，然后每一个素因子的k次方是一个元素，元素个数就是素因子个数。注意如果只有一个素因

     子，那么由于不能包含本身，所以多除一个素因子。

 

代码：

#include <iostream>
#include <stdlib.h>
#include <string.h>
#include <algorithm>
#include <stdio.h>

const int Times = 10;
const int N = 5500;

using namespace std;
typedef long long LL;

LL ct, cnt;
LL fac[N], num[N];

LL gcd(LL a, LL b)
{
    return b? gcd(b, a % b) : a;
}

LL multi(LL a, LL b, LL m)
{
    LL ans = 0;
    a %= m;
    while(b)
    {
        if(b & 1)
        {
            ans = (ans + a) % m;
            b--;
        }
        b >>= 1;
        a = (a + a) % m;
    }
    return ans;
}

LL quick_mod(LL a, LL b, LL m)
{
    LL ans = 1;
    a %= m;
    while(b)
    {
        if(b & 1)
        {
            ans = multi(ans, a, m);
            b--;
        }
        b >>= 1;
        a = multi(a, a, m);
    }
    return ans;
}

bool Miller_Rabin(LL n)
{
    if(n == 2) return true;
    if(n < 2 || !(n & 1)) return false;
    LL m = n - 1;
    int k = 0;
    while((m & 1) == 0)
    {
        k++;
        m >>= 1;
    }
    for(int i=0; i<Times; i++)
    {
        LL a = rand() % (n - 1) + 1;
        LL x = quick_mod(a, m, n);
        LL y = 0;
        for(int j=0; j<k; j++)
        {
            y = multi(x, x, n);
            if(y == 1 && x != 1 && x != n - 1) return false;
            x = y;
        }
        if(y != 1) return false;
    }
    return true;
}

LL pollard_rho(LL n, LL c)
{
    LL i = 1, k = 2;
    LL x = rand() % (n - 1) + 1;
    LL y = x;
    while(true)
    {
        i++;
        x = (multi(x, x, n) + c) % n;
        LL d = gcd((y - x + n) % n, n);
        if(1 < d && d < n) return d;
        if(y == x) return n;
        if(i == k)
        {
            y = x;
            k <<= 1;
        }
    }
}

void find(LL n, int c)
{
    if(n == 1) return;
    if(Miller_Rabin(n))
    {
        fac[ct++] = n;
        return ;
    }
    LL p = n;
    LL k = c;
    while(p >= n) p = pollard_rho(p, c--);
    find(p, k);
    find(n / p, k);
}

int main()
{
    int T;
    scanf("%d", &T);
    while(T--)
    {
        LL n;
        scanf("%I64d",&n);
        ct = 0;
        find(n, 120);
        sort(fac, fac + ct);
        num[0] = 1;
        int k = 1;
        for(int i=1; i<ct; i++)
        {
            if(fac[i] == fac[i-1])
                ++num[k-1];
            else
            {
                num[k] = 1;
                fac[k++] = fac[i];
            }
        }
        cnt = k;
        LL ans = 0;
        for(int i=0;i<cnt;i++)
        {
            LL t = 1;
            for(int j=0;j<num[i];j++)
                t *= fac[i];
            ans += t;
        }
        if(cnt == 1) ans /= fac[0];
        printf("%I64d %I64d\n", cnt, ans);
    }
    return 0;
}

 

题目：http://icpc.njust.edu.cn/Problem/Local/1722/

 

题意：给定一个数，有如下条件

 

    

 

     其中对任意的，都有，和，求表达式

 

     的值。

 

分析：当然是素因子分解了，然后注意乘法要改为二分形式，因为10000000019很大。

 

代码：

#include <iostream>
#include <string.h>
#include <algorithm>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

using namespace std;
typedef unsigned long long LL;

const LL Times = 10;
const LL N = 555;
const LL MOD = 10000000018;

LL ct, cnt, c, n;
LL fac[N], num[N];
LL arr[N];

LL gcd(LL a, LL b)
{
    return b? gcd(b, a % b) : a;
}

LL multi(LL a, LL b, LL m)
{
    LL ans = 0;
    a %= m;
    while(b)
    {
        if(b & 1)
        {
            ans = (ans + a) % m;
            b--;
        }
        b >>= 1;
        a = (a + a) % m;
    }
    return ans;
}

LL quick_mod(LL a, LL b, LL m)
{
    LL ans = 1;
    a %= m;
    while(b)
    {
        if(b & 1)
        {
            ans = multi(ans, a, m);
            b--;
        }
        b >>= 1;
        a = multi(a, a, m);
    }
    return ans;
}

bool Miller_Rabin(LL n)
{
    if(n == 2) return true;
    if(n < 2 || !(n & 1)) return false;
    LL m = n - 1;
    int k = 0;
    while((m & 1) == 0)
    {
        k++;
        m >>= 1;
    }
    for(int i=0; i<Times; i++)
    {
        LL a = rand() % (n - 1) + 1;
        LL x = quick_mod(a, m, n);
        LL y = 0;
        for(int j=0; j<k; j++)
        {
            y = multi(x, x, n);
            if(y == 1 && x != 1 && x != n - 1) return false;
            x = y;
        }
        if(y != 1) return false;
    }
    return true;
}

LL pollard_rho(LL n, LL c)
{
    LL i = 1, k = 2;
    LL x = rand() % (n - 1) + 1;
    LL y = x;
    while(true)
    {
        i++;
        x = (multi(x, x, n) + c) % n;
        LL d = gcd((y - x + n) % n, n);
        if(1 < d && d < n) return d;
        if(y == x) return n;
        if(i == k)
        {
            y = x;
            k <<= 1;
        }
    }
}

void find(LL n, int c)
{
    if(n == 1) return;
    if(Miller_Rabin(n))
    {
        fac[ct++] = n;
        return ;
    }
    LL p = n;
    LL k = c;
    while(p >= n) p = pollard_rho(p, c--);
    find(p, k);
    find(n / p, k);
}

void dfs(int dept, LL product = 1)
{
    if(dept == cnt)
    {
        if(product <= (LL)sqrt(1.0*n) && (product + n / product) % 2 == 0 && (n / product - product)% 2 == 0)
            arr[c++] = product;
        return;
    }
    for(int i=0; i<=num[dept]; i++)
    {
        dfs(dept + 1, product);
        product *= fac[dept];
    }
}

int main()
{
    int T, tt = 1;
    cin>>T;
    while(T--)
    {
        cin>>n;
        printf("Case %d: ",tt++);
        if(n == 1)
        {
            puts("1");
            continue;
        }
        ct = c = 0;
        find(n, 120);
        sort(fac, fac + ct);
        num[0] = 1;
        LL k = 1;
        for(int i=1; i<ct; i++)
        {
            if(fac[i] == fac[i-1])
                ++num[k-1];
            else
            {
                num[k] = 1;
                fac[k++] = fac[i];
            }
        }
        cnt = k;
        dfs(0, 1);
        sort(arr, arr + c);
        LL ans = 0;
        for(int i=0; i<c; i++)
        {
            LL x = (n / arr[i] + arr[i]) / 2;
            LL y = (n / arr[i] - arr[i]) / 2;
            ans += multi(x, x, MOD) + multi(y, y, MOD);
            ans %= MOD;
        }
        if(c > 0) cout<<quick_mod(n, ans, MOD + 1)<<endl;
        else puts("-1");
    }
    return 0;
}


 

 

大整数分解——Pollard Rho算法
xffyjq的博客
09-28 9938
延续上一篇，这次来讲一讲大整数分解算法的应用。要解决的问题很简单，对一个整数进行分解质因数。首先还是效率非常低的暴力算法，相信大家都会，不多提。和上次一样，当数达到非常大的时候，分解将变得非常困难。于是这次又带来一个提升分解速度的“非完美”算法。之所以打引号，是因为这次不完美的不是结果，而是时间效率。Pollard Rho算法分解一个数n的过程大体上是这样子的：1、找到一个数p，使得p|np|n，将
Pollard-rho大整数分解
AC_Gibson的专栏
07-06 3521
首先低于一般范围的整数分解，我们可以打一个素数表然后用试除的方法对其进行质因子分解。     具体实现代码如下： #include #include #include using namespace std; #define N 65555 bool p[N]; int prime[N],num=0; void init() { memset(p,true,sizeof(p));
分解大整数
05-23
分解120位整数，解决较大的整数分解问题，有椭圆曲线算法、特殊数域筛法、二次筛法等，而二次筛法是500bit及以下整数分解时，已知的最快算法。
整数（质因子）分解（Pollard rho大整数分解）
weixin_34253126的博客
01-21 1126
整数分解，又称质因子分解。在数学中，整数分解问题是指：给出一个正整数，将其写成几个素数的乘积的形式。 (每个合数都可以写成几个质数相乘的形式，这几个质数就都叫做这个合数的质因数。) 1.试除法（适用于范围比较小）    无论素数判定还是因子分解，试除法(Trial Division)都是首先要进行的步骤。令m=n,从2~根n一一枚举，如果当前数能够整除m，那么当前数就是n的素数因子，并用整数...
大整数分解——Pollard Rho算法(floyd判圈)
QAQ
08-23 3669
环境 : 给定一个数n,让你把它分解成多个素数的乘积 你离此算法大成就差一个Miller-Rabin素数检测算法了 对于一个数n,只需要如下步骤即可分成若干个素数 找到一个数p , 使p|n 那么n就可以变成p和n/p 如果p或者n/p不是质数,当成n重新第一步 判断是否为质数用Miller-Rabin素数检测算法 最关键的是如何找到这个数p...
整数分解PollardRho的思想
04-12
Pollard-Rho算法是一种整数分解算法，它利用随机数生成函数得到一个伪随机序列，该序列可以快速找到整数的因子。具体思想是利用随机数生成器生成随机数，然后通过迭代计算，得到一系列数值。在这些数值之间寻找循环...
因式分解
最新发布
06-28
**PollardRho算法**：这是一种快速分解大整数的概率算法，适用于大整数的分解。它基于随机行走和Floyd判圈算法，可以快速找到一个非平凡因子。 ###三、代码实现下面我们分别给出多项式因式分解（以二次三项式为例...
Pollard's Rho Algorithm——求正整数的质因数
小梓子的博客
04-01 1882
Pollard Monte Carlo factorization method 是J. M. Pollard 于1975提出的一种质因数分解的方法。由于其算法中迭代公式形成的序列点集合X={x1,x2,x3...xnx_1,x_2,x_3...x_n}形状与希腊字母ρ\rho相似，因此也叫Pollard’s rho algorithm。迭代的公式为：xn+1=(x2n+1)mod(N)n∈N;x_
Pollard Rho算法思想
07-28
1. 假定有两个整数 x 和 y，使得 p 可以整除 xy，但是 n 不能整除 xy。 2. 可以证明 p 可以整除 xy - 1，因为 p 可以整除 xy，可以写成 xy = kp。 3. 因为 n 不能整除 xy，所以 q 不能整除 n。这就表明 x 既可以是 1...
Pollard-Rho方法分解整数因子
RBS的专栏
09-10 4387
对于大整数而言，要找出其因子是比较困难的，事实上仍然没有很好的解决方法。不过在ACM里面有几种“标准的”方法可以使用，例如Pollard-Rho方法。 假设题目是求nn的因子，Pollard-Rho方法的基本思想是任意给定整数yy和xx，求gcd(y−x,n)gcd(y-x,n)。注意，所有运算都是在模nn的条件下进行的。如果gcd≠1且gcd≠ngcd\neq1且gcd\neq{n}，则gcdg
大数分解（基于非常大的整数的分解）
11-28
对大整数进行分解！
Pollard‘s rho大数分解算法
nameofcsdn的博客
04-26 4261
目录 一，问题 二，Pollard's rho算法思路 1，构造递推数列 2，生成mod n的递推数列 3，近似生日问题 4，Pollard's rho算法思路 5，时间复杂度 一，问题 给定一个很大的整数n，求出n的一个素因子 PS：如果求不出非平凡因子，也能说明n是素数 二，Pollard's rho算法思路 1，构造递推数列 构造一个一阶至少二次的递推式，如 2，生成mod n的递推数列 随便取初始值，根据得到一个数列，那么数列的每一项都在[0,n-1]的范围内 .
大整数分解 浅析
STJqwq的博客
07-13 1727
解决：质因数分解大整数 nnn 。1≤n≤10181\le n\le 10^{18}1≤n≤1018 。枚举 [2,n][2,\sqrt n][2,n​] 的所有质数，判断是否整除。除完之后只剩一个 质数 或者 111 了。时间复杂度 O(nln⁡n)O(\dfrac{\sqrt n}{\ln n})O(lnnn​​) 。这是一个笨方法，但是它告诉我们一些性质：​ 。（质数除外） 2.玄学法 玄学多好啊（先判断 nnn 是不是质数，然后在 [2,n][2,\sqrt n][2,n​] 里面随机选取一个整
整数分解
web116629的博客
10-23 909
Pollard_rho算法模板(大整数的因子分解)
Learn as if you were to live forever
08-09 8093
还是没怎么看懂Pollard_rho算法的原理，以后再来啃过。。。 int pollard_rho(int n, int c) { int x, y, d, i = 1, k = 2; x = rand() % (n - 1) + 1; y = x; while (true) { ++i; x = (modular_multi(x, x, n) + c) % n; d = g
Pollard_rho大数因数分解
linz的博客
08-05 1788
从今天终于把这个算法整理出来了，比较弱理解起来有点慢（目前也不怎么懂），但是能愉快的运行了hhhh 题目链接：https://nanti.jisuanke.com/t/28395  Pollard_rho算法的大致流程是 先判断当前数是否是素数（Miller_rabin）了，如果是则直接返回。如果不是素数的话，试图找到当前数的一个因子（可以不是质因子）。然后递归对该因子和约去这个因子的另一个因...
大整数分解与两类特殊的素数及其猜测
weixin_43817941的博客
10-04 2909
本文探讨了大整数的分解问题，给出了大整数分解的三类方法，并针对两类素数提出了两个新的猜想。
大整数因数分解工具——yafu
l2ohvef的博客
02-16 5569
可以将大整数放在一个新建文件中——data.txt，最后面一定要换行，不然会出现eof;done processing batchfile，运行命令。2.点击设置——系统——系统信息——高级系统设置——环境变量——点击PATH（上下都可以）——新建 添加yafu-x64.exe 所在路径——点击确定。，如果整数数过长，会出现错误mismatched parens；1.找到yafu-x64.exe 所在的文件路径。如果出现以下图像，说明配置成功。3.打开cmd,输入。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值