PollardRho大整数分解

最新推荐文章于 2022-10-04 00:02:24 发布
最新推荐文章于 2022-10-04 00:02:24 发布
阅读量7k 收藏 3
点赞数 4
分类专栏： 数论
版权声明：本文为博主原创文章，遵循 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;
}


 

 

ACdreamers
关注
  • 4
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Pollard-rho大整数分解
AC_Gibson的专栏
07-06 3325
首先低于一般范围的整数分解，我们可以打一个素数表然后用试除的方法对其进行质因子分解。     具体实现代码如下： #include #include #include using namespace std; #define N 65555 bool p[N]; int prime[N],num=0; void init() { memset(p,true,sizeof(p));
大整数分解 浅析
STJqwq的博客
07-13 1492
解决：质因数分解大整数 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​] 里面随机选取一个整
大整数分解——Pollard Rho算法(floyd判圈)
jkchen's Haven
08-23 3292
环境 : 给定一个数n,让你把它分解成多个素数的乘积 你离此算法大成就差一个Miller-Rabin素数检测算法了 对于一个数n,只需要如下步骤即可分成若干个素数 找到一个数p , 使p|n 那么n就可以变成p和n/p 如果p或者n/p不是质数,当成n重新第一步 判断是否为质数用Miller-Rabin素数检测算法 最关键的是如何找到这个数p...
大整数分解——Pollard Rho算法
xffyjq的博客
09-28 8958
延续上一篇，这次来讲一讲大整数分解算法的应用。要解决的问题很简单，对一个整数进行分解质因数。首先还是效率非常低的暴力算法，相信大家都会，不多提。和上次一样，当数达到非常大的时候，分解将变得非常困难。于是这次又带来一个提升分解速度的“非完美”算法。之所以打引号，是因为这次不完美的不是结果，而是时间效率。Pollard Rho算法分解一个数n的过程大体上是这样子的：1、找到一个数p，使得p|np|n，将
整数（质因子）分解（Pollard rho大整数分解）
weixin_34253126的博客
01-21 911
整数分解，又称质因子分解。在数学中，整数分解问题是指：给出一个正整数，将其写成几个素数的乘积的形式。 (每个合数都可以写成几个质数相乘的形式，这几个质数就都叫做这个合数的质因数。) 1.试除法（适用于范围比较小）    无论素数判定还是因子分解，试除法(Trial Division)都是首先要进行的步骤。令m=n,从2~根n一一枚举，如果当前数能够整除m，那么当前数就是n的素数因子，并用整数...
Pollard-Rho方法分解整数因子
RBS的专栏
09-10 4200
对于大整数而言，要找出其因子是比较困难的，事实上仍然没有很好的解决方法。不过在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
java版大数分解算法之PollardRho
09-08
大数分解算法啊，哈哈哈哈，很好，我爱java
离散对数赛题
11-30
在密码学背景及相关研究进展部分，介绍了求解离散对数问题的一些常见算法，比如Shanks的大步小步算法、Pollardrho算法、Pohlig-Hellman算法、IndexCalculus算法等。其中，针对大素数的离散对数问题，应用数域筛法...
分解大整数
05-23
分解120位整数，解决较大的整数分解问题，有椭圆曲线算法、特殊数域筛法、二次筛法等，而二次筛法是500bit及以下整数分解时，已知的最快算法。
大整数的分解.pdf
12-20
大整数的分解作为密码学的重要的基础知识，如现在使用的RAS算法。
大数分解（基于非常大的整数的分解）
11-28
对大整数进行分解！
整数分解
web116629的博客
10-23 849
Pollard_rho算法模板(大整数的因子分解)
Learn as if you were to live forever
08-09 7963
还是没怎么看懂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 1672
从今天终于把这个算法整理出来了，比较弱理解起来有点慢（目前也不怎么懂），但是能愉快的运行了hhhh 题目链接：https://nanti.jisuanke.com/t/28395  Pollard_rho算法的大致流程是 先判断当前数是否是素数（Miller_rabin）了，如果是则直接返回。如果不是素数的话，试图找到当前数的一个因子（可以不是质因子）。然后递归对该因子和约去这个因子的另一个因...
大整数分解与两类特殊的素数及其猜测
weixin_43817941的博客
10-04 1899
本文探讨了大整数的分解问题，给出了大整数分解的三类方法，并针对两类素数提出了两个新的猜想。
Pollard Rho 大整数分解
I wonder how , I wonder why !!
08-21 1500
http://www.cnblogs.com/jackiesteed/articles/2019910.html 1975年，John M. Pollard提出了第二种因数分解的方法。Pollard rho因数分解方法基于下列几点： (1) 假定有两个整数 和 使得p可以整除-，但是n不能整除 。 (2) 可以证明 。因为p可以整除- ，可以写成 。但是，因为n不能整除-，很
数论 —— 整数分解
热门推荐
Alex_McAvoy的博客
08-01 1万+
【概述】 整数分解目前仍是世界级难题，是非常重要的研究方向，其有很多种算法，性能上各有差异，本文仅介绍试除法、Fermat 算法、Pollard Rho 算法。 【试除法】 试除法也叫穷举法，是整数分解算法中最简单和最容易理解的算法，但也是效率最低的算法。 试除法是用小于等于 n 的每个素数去试除待分解的整数，如果找到一个数能够整除除尽，这个数就是待分解整数的因子。 试除法一定能够找到 ...
大整数分解因子算法——Dixon的随机平方算法
国科大网安二班的博客
03-05 2504
大整数分解因子算法——Dixon的随机平方算法 许多分解因子算法的理论依据是这样的事实： 假设我们可以找到x≢±y(modn)x\not\equiv \pm y\pmod{n}x​≡±y(modn)，但是有x2≡y2(modn)x^{2}\equiv y^{2}\pmod{n}x2≡y2(modn)。那么有 n∣(x−y)(x+y) n|(x-y)(x+y) n∣(x−y)(x+y) 但是n∤(x+y)n\nmid (x+y)n∤(x+y)且n∤(x−y)n\nmid (x-y)n∤(x−y)，所以gc
浅谈RSA算法与大整数分解
xbb0720的博客
10-31 1万+
前言： 最近做了一个以RSA算法为原型的题，这里对其中涉及到的问题及算法进行一个分析和总结。   RSA算法简介： RSA算法是一种加密算法，广泛应用于现在的信息加密传输等领域，它的狭义应用流程如下： 现在加如你需要传送某一串信息M(这里简化为数字)给一些人，利用RSA算法加密以后你可以得到一个密文C，然后你将密文C传送给你需要传达的人，而对方有一个密钥D，对方可以比较容易地利用密钥D将...
整数分解PollardRho的思想
最新发布
04-12
Pollard-Rho算法是一种整数分解算法，它利用随机数生成函数得到一个伪随机序列，该序列可以快速找到整数的因子。具体思想是利用随机数生成器生成随机数，然后通过迭代计算，得到一系列数值。在这些数值之间寻找循环...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值