POJ 2429 Miller-rabin素数判定 + pollard-rho质因子分解 + 埃氏筛法

这篇具有很好参考价值的文章主要介绍了POJ 2429 Miller-rabin素数判定 + pollard-rho质因子分解 + 埃氏筛法。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

题目不能说是很难,只是用到了许多数学上的知识(费马小定理,miller-radin,pollard-rho),还有一些算法上的知识DFS,辗转相除。

我也很菜,一个周末的时间都用在这个题目上了,但写了很多很多的注释,花费了大量的篇幅,浅谈了我对这些算法的拙见,希望能够帮助大家!

POJ 2429 Miller-rabin素数判定 + pollard-rho质因子分解 + 埃氏筛法,算法文章来源地址https://www.toymoban.com/news/detail-648263.html

#include <iostream>
#include <vector>
#include <set>
#include <map>
#include <algorithm>
using namespace std;
// 无符号的64位整数,可以支持 18446744073709551615 (2^64 - 1 )
typedef unsigned long long ll;
// 我们把前30000的素数打个表
int primeLimit = 30000;
bool isPrime[30007];
// facPrime存放的是质数因子,例如对9000000000000000000来说,存放的是 2 2 2 2 ... 2 3 3 5 5 ...5 5 5 5 5,这些质因子相乘等于lcm/gcd
vector<ll> facPrime;
// facVector存放的是互质的因子,例如对9000000000000000000存放的是 2^18 3^9 5^18,即262144 9 3814697265625,这些因子相乘等于 lcm/gcd
vector<ll> facVector;
// 最终输出的结果
ll a, b;
// 米勒拉宾算法需要一个r和一个d,在下面会解释
ll r, d;
// 我们用埃氏筛法来找出 30000以内的素数
void sieve()
{
    for (int i = 1; i <= primeLimit; i++)
    {
        isPrime[i] = true;
    }
    // 0和1不是素数
    isPrime[0] = false;
    isPrime[1] = false;
    // 如果num不是素数,那么一定存在除了1之外,且小于等于根号num的数字i,使得 num是i的倍数,这就是埃氏筛法的原理
    for (int i = 2; i * i <= primeLimit; i++)
    {
        // 如果i不是素数,就跳过,这里跳过是为了加快效率,假如 i是18,那么18的倍数i一定是3的倍数,3的倍数在前面的循环已经设置了,那么就不用管了
        if (!isPrime[i])
        {
            continue;
        }
        // 如果i是素数,那么i的所有倍数一定都不是素数
        for (int j = i * 2; j <= primeLimit; j += i)
        {
            isPrime[j] = false;
        }
    }
}
// 生成一个小于p,且大于0的随机数
ll getLongRandom(ll p)
{
    int x = 0;
    // x需要大于0
    while (x == 0)
    {
        x = rand();
        // x需要是正数
        if (x < 0)
        {
            x = x * (-1);
        }
        // x需要小于p
        if (x >= p)
        {
            x = x % p;
        }
    }
    return (ll)x;
}
// 计算 (a * b) % mod,并且使得对于2^63以下的a,b,计算过程都不溢出,本质的原理就是乘法,只是我们自己算是10进制乘法,它是二进制乘法
ll mulMod(ll a, ll b, ll mod)
{
    ll res = 0;
    while (b)
    {
        // b&1就是b与1按位与的结果,当前仅当b的最低位是1时生效,如 十进制 11 & 1 = 二进制 1011 & 1 = 1
        if (b & 1)
        {
            res = (res + a) % mod;
        }
        // 左移就是*2,同时取余防止溢出,就相等于乘法中的进位
        a = (a << 1) % mod;
        // 右移就是/2,这样才能不断的计算最高位
        b = b >> 1;
    }
    return res;
}
// 用快速乘来优化的快速幂,快速幂可以去挑战程序设计里学一下,这里不再赘述
ll powMod(ll a, ll b, ll mod)
{
    ll res = 1;
    while (b)
    {
        if (b & 1)
        {
            res = mulMod(res, a, mod);
        }
        a = mulMod(a, a, mod);
        b = b >> 1;
    }
    return res;
}
// 根据大的奇数p,计算 (2^r)*d=p-1,其中d是一个奇数
void getRD(ll p)
{
    // 首先让 d = p-1,之后不断的除以2,直到d是一个奇数,同时每次除以2,r都+1,这样最终 (2^r)*d=p-1了
    d = p - 1;
    r = 0;
    // d转换为二进制最低位如果是1,d&1就是1,那么也就是一个奇数,反之,当d&1=0时,d也就是一个偶数
    // !(d&1) 就是 d&1 !=1 ,就是 d时一个偶数
    while (!(d & 1))
    {
        // d最左移1位,就是d/2
        d = d >> 1;
        r++;
    }
    // 例如 p=25时d=24,r=0 -> d=12,r=1 -> d=6,r=2 -> d=3 r=3 最终求出 (2^3)*3 = 25 - 1,算出 d=3,r=3
}
// 米勒拉宾算法判断素数
bool millerRabin(ll p)
{
    // 这里引入费马小定理, 当 p 时一个素数时,对任意的整数a,一定有 pow ( a , p ) % p == a % p
    // 当 1 <= a <= p - 1 我们对等式两边同时除以 a,得到 pow ( a , p - 1 ) % p == 1
    // 所以只要对于大整数 p 和随机数 a ,如果不满足这个规则,那么p一定不是素数
    ll a = getLongRandom(p);
    if (powMod(a, p - 1, p) != 1)
    {
        return false;
    }
    // 为了提高算法的准确性,我们把 pow ( a , p - 1 ) % p == 1 进行推导,这里用  a ^ (p-1) 代表a的 p - 1 次方
    //  a ^ ( p - 1 ) % p == 1
    // 定义 r d,使得 ( 2 ^ r ) * d = p - 1
    // a ^ ( ( 2 ^ r ) * d ) % p == 1
    // ( a ^ ( ( 2 ^ r ) * d ) - 1 ) % p == 0
    // 这里可以使用平方差公式进行推导
    // (a ^ ( (2 ^ (r - 1) ) * d) - 1) * (a ^ ( (2 ^ (r - 1) ) * d) + 1 ) % p == 0
    // (a ^ ( (2 ^ (r - 2) ) * d) - 1) * (a ^ ( (2 ^ (r - 2) ) * d) + 1 ) * (a ^ ( (2 ^ (r - 1) ) * d) + 1) % p == 0
    // ....
    // (a ^ ( (2 ^ (r - r) ) * d) - 1) * (a ^ ( (2 ^ (r - r) ) * d) + 1) * ...  (a ^ ( (2 ^ (r - 1) ) * d) + 1) % p == 0
    // 同时p是素数,如果这些项相乘 % p == 0,那么其中的某一项一定等于0,那么就推出了另外一个判断依据
    // 在  0 <= i < r 必定存在 a ^ ( (2 ^ i) * d) 等于 p 或等于 1,否则 p 一定不是素数
    // a ^ ( (2 ^ i) * d) = (a ^ d) ^ (2 ^ i)
    ll k = powMod(a, d, p);
    for (int i = 0; i < r; i++)
    {
        // 计算每一项
        ll parameter = powMod(k, powMod(2, i, p), p);
        if (parameter == 1 || parameter == p - 1)
        {
            return true;
        }
    }
    return false;
}
// 米勒拉宾具有概率性,我们连续判断20次,如果都满足,那么它一定是素数!
bool multiMillerRabin(ll p)
{
    // 对于固定的p,只需要计算1次,使得 (2 ^ ( r ) * d) == p - 1 的r和d
    getRD(p);
    for (int i = 0; i < 20; i++)
    {
        if (!millerRabin(p))
        {
            return false;
        }
    }
    return true;
}
// 质数判断方法,对于30000以内的小素数,直接用 “埃氏筛法” ,对于30000以上的,偶数直接可以确定不是质数,奇数的话,2 ^ 63 次幂以下,用米勒拉宾没问题
bool judgePrime(ll p)
{
    if (p <= primeLimit)
    {
        return isPrime[(int)p];
    }
    else if (!(p & 1))
    {
        // 举个例子,p = 30002 ,也就是二进制的 0111 0101 0011 0010 和 0000 0000 0000 0001 按位与一定是 0 ,!0就是1就是true
        return false;
    }
    else
    {
        // 直接用米勒拉宾判断20次
        return multiMillerRabin(p);
    }
}
// 辗转相除求出gcd
ll gcd(ll a, ll b)
{
    if (b == 0)
    {
        return a;
    }
    else
    {
        return gcd(b, a % b);
    }
}
// | a - b |  a,b相减的绝对值
ll absSub(ll a, ll b)
{
    if (a > b)
    {
        return a - b;
    }
    else
    {
        return b - a;
    }
}
// 使用ρ算法,来高效的分解质因子!
void pollardRho(ll p)
{
    // 如果p是素数,那就代表找到了一个质因子
    if (judgePrime(p) || p <= 1)
    {
        // facPrime存放的是质数因子,例如对9000000000000000000来说,存放的是 2 2 2 2 ... 2 3 3 5 5 ...5 5 5 5 5,这些质因子相乘等于lcm/gcd
        if (p >= 2)
        {
            facPrime.push_back(p);
            return;
        }
    }
    // 我还没有理解ρ算法特别深,但是可以浅谈下自己的拙见!如果错误的话,大家批评指正!
    // 它是产生随机数x,然后判断随机数x 和 p 是否存在 大于1的最大公约数 g
    // 存在的话就对 g 和 p / g 分别递归应用ρ算法,直到找到素数,是一个递归出口
    // 但是如果单纯的随机产生x,实在速度太慢
    // 这里引入一个生日悖论,不考虑闰年时,23个人中有两个人生日相同的概率超过 二分之一
    // 1 - ( 365.0 / 365.0 ) * ( 364.0 / 365.0 ) * ( 363.0 / 365.0 ) * ( 343.0 / 365.0 ) > 0.5
    // 所以我们也可以学一下这个生日悖论,产生一堆随机数 x1 x2 x3 x4 ... xn
    // 当n足够大时,那么其中的任意两个数 xi xj 的差与 p 存在大于1的最大公约数的概率会很大!
    // 同时如果循环的去算 xi - xj,也太慢了!所以让 xi 与 xi-1 存在一个关系,即 x2 = x1*x1 +c ,x3 = x2*x2+c,x4=x3*x3+c,(c和x1是小于p大于0的随机数)
    // 那么算出来的随机数就存在相互关系,产生的曲线是一个ρ型,当其中某一个 xj - xi 与 p 存在大于1 的最大公约数时
    // 那么对于 任意的 对于任意的 xk,k>j也一定有 xk - xi 与p存在大于1的最大公约数(这里是我的理解,我不会证明)
    // 同时曲线是一个 ρ 型,那么容易出现 循环,比如 x1 = 3 a = 2 p = 20
    // x1 = 3 ,x2 = (3*3+2)%20=11,x3 = (11*11 + 2) %20=3 ,x3又回到了x1,出现了si循环!
    // 所以我们让y以x两倍的速度去增长,即每次循环y算两次,x算一次,那么就类似于数学中的追击问题,定会有x和y相遇
    // 当x==y,我们重新生成随机的x1和c重新找因子!
    // 然后递归的时候,判断如果p是一个质数,就是递归出口!
    bool isFind = false;
    // 找不到就一直找,找到了直接出循环
    while (!isFind)
    {
        ll x = getLongRandom(p);
        ll c = getLongRandom(p);
        ll y = x;
        y = (mulMod(y, y, p) + c) % p;
        while (x != y)
        {
            ll gcdNum = gcd(p, absSub(y, x));
            if (gcdNum > 1)
            {
                // 找到了最大公约数,那么最大公约数就是因子,用 p 除以这个因子,可以得到另一个因子,再分别带进去循环,最终一定可以找到所有的质数因子
                pollardRho(gcdNum);
                pollardRho(p / gcdNum);
                isFind = true;
                break;
            }
            x = (mulMod(x, x, p) + c) % p;
            y = (mulMod(y, y, p) + c) % p;
            y = (mulMod(y, y, p) + c) % p;
        }
    }
}
// 用dfs来判断因子间排列组合相乘的各种情况!找到最小的 a+b
void dfs(int i, ll current, ll p)
{
    if (i >= facVector.size())
    {
        return;
    }
    // 乘以这个因子的情况算一下
    ll currentA = current * facVector[i];
    ll currentB = p / currentA;
    if ((currentA + currentB) < (a + b))
    {
        a = currentA;
        b = currentB;
    }
    dfs(i + 1, current * facVector[i], p);
    // 不乘以这个因子的情况再算一下
    currentA = current;
    currentB = p / currentA;
    if ((currentA + currentB) < (a + b))
    {
        a = currentA;
        b = currentB;
    }
    dfs(i + 1, current, p);
}
int main()
{
    ll lcm, gcd;
    // 初始化埃氏筛法
    sieve();
    while (~scanf("%lld%lld", &gcd, &lcm))
    {
        // 不难看出,当 a b 的最大公约数是gcd,最小公倍数是lcm时
        // 一定有 ( lcm / gcd ) = ( a / gcd ) * ( b / gcd )
        // 同时也一定有( a / gcd ) * ( b / gcd )互质,如果它们不互质,那最大公约数不会是gcd,应该是它们的公约数 * gcd才对!
        // 因此我们要根据lcm和gcd去求解原数字,其实很简单
        // 定义 p = lcm/gcd ,把p变成质因子相乘的形式
        // 假设  p = 9000000000000000000 ,就把它变成 2 * 2 * 2 * 2 * 2 * 2 * 2 .. * 2 * 3 * 3 * 5 * 5 .... * 5
        // 设 (a/gcd)=a1,(b/gcd)=b1
        // 那么一定有 a1 * b1 = 2 * 2 * 2 * 2 * 2 * 2 * 2 .. * 2 * 3 * 3 * 5 * 5 .... * 5 = (2 ^ 18)*(3 ^ 2)*(5 ^ 18)
        // 同时a1和b1还互质,不能存在公约数,那么a的质因子和b的质因子就不能有重复,有重复的话,gcd(a1,b1)无法等于1,a和b的gcd就与输入的gcd不符
        // 那么我们就推导一下思路:
        // 输入了 lcm 和 gcd,我们用 lcd / gcd 算出一个 p,然后把 p 推导成 p = a1 * b1 的形式,找出满足a1 和 b1 互质,且(a1+b1)最小的a1和b1
        // 然后输出 a1 * gcd 和 b1 * gcd就是结果
        // 同时当lcm与gcd相等时,不需要找,直接输出gcd就好,当且仅当a和b相等时,它们的gcd和lcm才相等,而且都等于a
        // 对于 9223372036854775807 规模的p, 把 p 推到成 p = a1 * b1 的过程并不容易,所以我们引入了 pollard-rho 算法,求出 p 的质因子
        // 把 p 写成一堆质数的次方,相乘的形式,然后 dfs,依次判断每一项乘上与不乘上的值,找出最小的 a1 + b1,最后输出答案
        // a1 * b1 = (2 ^ 18) * (3 ^ 2) * (5 ^ 18),只要 a 和 b是右边三项中的任意1或多项 乘出来的,那么它们一定互质!
        ll p = lcm / gcd;
        if (p == 1)
        {
            // 当且仅当 a==b,的时候,lcm 与 gcd才相等,而且都等于a
            printf("%lld %lld\n", gcd, gcd);
        }
        else
        {
            // 质因子数组初始化
            if (facPrime.size() > 0)
            {
                facPrime.clear();
            }
            // 因子数组初始化
            if (facVector.size() > 0)
            {
                facVector.clear();
            }
            pollardRho(p);
            // 用来统计每个质因子出现数量的map
            map<ll, ll> countMap;
            // 用来对质因子去重的set
            set<ll> distinctSet;
            for (int i = 0; i < facPrime.size(); i++)
            {
                countMap[facPrime[i]] = 0;
                distinctSet.insert(facPrime[i]);
            }
            for (int i = 0; i < facPrime.size(); i++)
            {
                ll count = countMap[facPrime[i]];
                countMap[facPrime[i]] = count + 1;
            }
            for (set<ll>::iterator ite = distinctSet.begin(); ite != distinctSet.end(); ite++)
            {
                ll prime = *ite;
                prime = powMod(prime, countMap[prime], p);
                if (prime == 0)
                {
                    prime = p;
                }
                facVector.push_back(prime);
            }
            a = facVector[0];
            b = p / a;
            dfs(0, 1, p);
            if (a > b)
            {
                swap(a, b);
            }
            a = a * gcd;
            b = b * gcd;
            printf("%lld %lld\n", a, b);
        }
    }
    return 0;
}

到了这里,关于POJ 2429 Miller-rabin素数判定 + pollard-rho质因子分解 + 埃氏筛法的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

原文地址:https://blog.csdn.net/qq_53038151/article/details/132286914

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包