模板 - 扩展大步小步算法

最新推荐文章于 2024-02-19 17:11:32 发布

weixin_30618985

最新推荐文章于 2024-02-19 17:11:32 发布

阅读量80

点赞数

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/Yinku/p/10968110.html

本文深入讲解了BSGS算法，一种在O(√p)复杂度内解决离散对数问题的方法。通过分解未知数x，利用大步小步法，算法高效地解决了形如a^x ≡ b mod p的同余式，其中p为质数。文章还探讨了原根的概念及其在求解此类问题中的应用，并提供了详细的代码实现。

我又来开新坑了，先是不扩展的。

在 $O(\sqrt p)$ 复杂度内，求最小的 $x$ 在 $[0,p)$ 使得，已知 $a,b,p$ 的同余式 $a^{x} \equiv b\: mod\: p$ 成立其中 $p$ 是质数。

首先可以把 $x$ 分解为 $A \lceil \sqrt p \rceil - B$ ，其中 $A,B$ 都在 $ \lceil \sqrt p \rceil $内
$a^{A \lceil \sqrt p \rceil - B} \equiv b\: mod\: p$

然后同乘
$a^{A \lceil \sqrt p \rceil} \equiv ba^{B}\: mod\: p$
枚举 $ B $ 保存右边的值，然后枚举 $A$ ，计算左边的值是否可以从右边得出。kuangbin的板子有问题，贴一个其他人的模板。

吸氧之后跑得飞快！

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;

inline int gcd(int a,int b){
    if(!b)
        return a;
    else{
        while(int i=a%b){
            a=b;
            b=i;
        }
        return b;
    }
}

inline int qpow(ll a,int n,int m) {
    //这个快速幂保证p不是1，少模一次是一次
    ll s=1;
    while(n) {
        if(n&1)
            s=s*a%m;
        a=a*a%m;
        n>>=1;
    }
    return s;
}

unordered_map<int,int> M;
//要求a,n互质 a^x=b mod n .k,t是留给exbsgs调用的
int bsgs(int a,int b,int n,int k=1,int t=0) {
    if(b==1)
        return 0;
    M.clear();
    int m=ceil(sqrt(n));
    ll s=b;//BS
    for(int i=0; i<m; i++,s=s*a%n)
        M[s]=i;

    s=k;//GS
    k=qpow(a,m,n);
    for(ll i=1; i<=m; i++) {
        s=s*k%n;
        if(M.count(s))
            return i*m-M[s]+t;  //貌似这样就保证找到的是最小解了，不知道为什么
    }
    return -1;
}

//a^x=b mod n
int exbsgs(int a,int b,int n) {
    if(b==1) {
        return 0;
    }
    int d=gcd(a,n),k=1,t=0;
    while(d^1) {
        if(b%d) {
            return -1;
        }
        ++t;
        b/=d;
        n/=d;
        k=(ll)k*(a/d)%n;
        if(b==k) {
            return t;
        }
        d=gcd(a,n);
    }
    return bsgs(a,b,n,k,t);
}

int main() {
    int a,b,n;
    while(1) {
        scanf("%d%d%d",&a,&n,&b);
        if(!a&&!n&&!b)
            break;
        a%=n;
        b%=n;
        int ans=exbsgs(a,b,n);
        if(ans==-1)
            puts("No Solution");
        else
            printf("%d\n",ans);
    }
    return 0;
}

例如求 $x^a = b \: mod \: n$

原根的引入

当 $gcd(a,p)==1$ ，由欧拉定理，存在正整数 $d$ 使得 $a^d \equiv 1 \: mod \: p$ ，例如 $d=\varphi(p)$。

阶

$gcd(a,p)==1$ ，阶为 $a$ 在模 $p$ 意义下的最小的正整数 $d$ 。

原根

$a$ 在模 $p$ 意义下的阶 $d=\varphi(p)$ 时，$a$ 为模 $p$ 的（其中一个）原根。 $p$ 共有 $\varphi(\varphi(p))$ 个原根。

当且仅当 $n=1,2,4,p^e,2p^e$ ，$p$ 是质数且 $p>2$ ， $e$ 是正整数时有原根。当原根存在时，其分布是比较均匀的，可以暴力找到原根。
找到原根 $g$ 后，一定找到一个指数 $i$ ，使得 $x=g^i$， $0 \leq x,i < n$ 。

明显数字比较小的时候你可以瞎搞，只讨论是质数的情况。

$x^a = b \: mod \: p$
取得 $p$ 的一个原根 $g$，用BSGS一定可以找到 $b$ 对应的原根的指数 $j$ ，即 $g^j= b\: mod \: p$。
设 $x$ 可以表示为 $g^i= x\: mod \: p$ ，那么原式变为 $(g^i)^a= g^j \: mod \: p$ 。

用欧拉定理拿下来：
$ia= j \: mod \: p-1$

就是求线性同余方程 $ax= b \: mod \: n$ 的解，用exgcd就可以求出来一个特解 $i$ 。
然后根据特解构造出 $[0,p)$ 内的所有解 $i$，然后快速幂复原出 $x=g^i \: mod \: p$

当只要求一次原根时，筛法显得多余。而确定了 $p$ 是质数时，不仅原根不需要求欧拉函数，还不需要扩展大步小步。
所以先满足代码短：

$p$ 是质数的求法

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;

inline int gcd(int a,int b) {
    if(!b)
        return a;
    else {
        while(int i=a%b) {
            a=b;
            b=i;
        }
        return b;
    }
}

inline ll qpow(ll x,int n,int mod) {
    //保证mod已经不会是1了
    ll ret=1;
    while(n) {
        if(n&1)
            ret=ret*x%mod;
        x=x*x%mod;
        n>>=1;
    }
    return ret;
}

unordered_map<int,int> M;
//要求a,n互质 a^x=b mod n .k,t是留给exbsgs调用的
int BSGS(int a,int b,int n,int k=1,int t=0) {
    if(b==1)
        return 0;
    M.clear();
    int m=ceil(sqrt(n));
    //BS
    ll s=b;
    for(int i=0; i<m; i++) {
        M[s]=i;
        s=s*a%n;
    }

    //GS
    s=k;
    k=qpow(a,m,n);
    for(ll i=1; i<=m; i++) {
        s=s*k%n;
        if(M.count(s))
            return i*m-M[s]+t;  //貌似这样就保证找到的是最小解了，不知道为什么
    }
    return -1;
}

//对p-1质因数分解，从0开始
int factor[60],ftop;
void Get_Factors(int x) {
    ftop=0;
    int tmp=x;
    for(int i=2;i*i<=tmp;++i) {
        if(tmp%i==0) {
            factor[ftop]=i;
            while(tmp%i==0)
                tmp/=i;
            ftop++;
        }
    }
    if(tmp!=1) {
        factor[ftop]=tmp;
    }
}

int Get_Primitive_Root(int p) {
    if(p==2)
        return 1;
    Get_Factors(p-1);
    for(int g=2; g<p; g++) {
        //逐个枚举他是不是原根
        int i;
        for(i=0; i<ftop; i++)
            if(qpow(g,p-1/factor[i],p)==1)
                break;
        if(i==ftop)
            return g;
    }
    //传了不对的p
    exit(-1);
}

int ex_gcd(int a,int b,int& x,int& y) {
    if(!b) {
        x=1,y=0;
        return a;
    }
    int d=ex_gcd(b,a%b,x,y);
    int temp=x;
    x=y;
    y=temp-a/b*y;
    return d;
}

//解线性同余方程: ax+by=c
bool _LCE(int a, int b, int c, int &x, int &y) {
    int x0,y0;
    int d=ex_gcd(a,b,x0,y0);
    if(c%d!=0)
        return 0;
    int k=c/d;
    x=x0*k;
    y=y0*k;
    return 1;
}

//解线性同余方程 ax = b mod n
//这个是和 ax + ny = b等价，注意变量
bool LCE(int a,int b,int n,int &x,int &t) {
    int x0,y0;
    if(_LCE(a,n,b,x0,y0)) {
        t=n/gcd(a,n);
        x=(x0%t+t)%t;
        return 1;
    } else
        return 0;
}

//这个上界是瞎猜的，看来蛮准的
int ans[100005],atop=0;

//求解所有的x满足x^a = b mod p
void solve(int a,int b,int p) {
    if(b==0){
        ans[atop++]=0;
        return;
    }
    int g=Get_Primitive_Root(p);
    int j=BSGS(g,b,p);

    int i,t;
    LCE(a,j,p-1,i,t);

    ll g1=qpow(g,i,p);
    int dg=qpow(g,t,p);
    for(int k=0;k<=p-1;k++) {
        ans[atop++]=g1;
        g1=g1*dg%p;
    }

    sort(ans,ans+atop);
    atop=unique(ans,ans+atop)-ans;
    return;
}

int main() {
#ifdef Yinku
    freopen("Yinku.in","r",stdin);
#endif // Yinku
    int p,a,b;
    scanf("%d%d%d",&p,&a,&b);
    solve(a,b,p);
    printf("%d\n",atop);
    for(int i=0; i<atop; i++)
        printf("%d\n",ans[i]);
    return 0;
}

不是质数的情况，把原根的 $p-1$ 还原为 $\varphi(p)$ ，然后用exBSGS就可以了。

转载于:https://www.cnblogs.com/Yinku/p/10968110.html