模板

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

---

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

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

然后同乘
(a^{A lceil sqrt p ceil} 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
",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
",atop);
    for(int i=0; i<atop; i++)
        printf("%d
",ans[i]);
    return 0;
}

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

---

阶：

定义：设m>1，a,m互质，则使得a^r=1 mod m成立的最小的正数r，称为a模m的阶，记为 delta_m(a)。

定理：若a^n=1 mod m，则delta_m(a)|n

原根：

定义：a是整数，m是正整数，若a模m的阶delta_m(a)=phi(m)，则a是m的“一个”原根。

性质：模m有原根的充要条件：m=2,4,p^a,2*p^a，其中p是奇质数。

性质：记原根为g，则g^i=1 mod m (1<=g<p,0<=i<m）的结果两两不同。

简单说 g^i=1 mod m 当，且仅当i==m-1时成立。

定理：如果a模m有原根，那么一共有phi(phi(m))个原根。

求模m素数的方法：对phi(m)质因数分解，分解出的每个不同质因子都拿phi(m)去除以，得到的记为x，若g^x != 1 mod m 对所有的x成立，则g是模m的“一个”原根。