模拟赛 T1 费马小定理+质因数分解+exgcd

求：$a^{bx \%p}\equiv 1(\mod p)$ 的一个可行的 $x$.

根据欧拉定理，我们知道 $a^{\phi(p)}\equiv 1(\mod p)$

而在 $a^x\equiv 1(\mod p)$ 这个式子中 $x$ 是存在很多个解的.

这些解之间存在着循环节，使得任意解 $x$ 可以被表示成循环节的倍数.

我们设这个循环节为 $cir$.

由于已知 $\phi(p)$ 一定是一个可行解，所以最小循环节一定是 $\phi(p)$ 的约数.

然后我们就可以对 $\phi(p)$ 进行质因数分解来求这个最小循环节 $cir$.

求出来 $cir$ 后，可得 $bx\%p=cir\times y$

你发现因为有这个 $\%p$ 操作，所以会导致这个方程解不出来.

但是好在我们发现，左面那个式子可以变为 $bx+pk=l$，而这个 $l$ 可以被表示为 $i\times gcd(b,p)$

故我们可以将式子变为 $i\times gcd(b,p)=y\times cir$.

然后我们可以对这个求最小通解（因为如果最小解小于 $p$，则一定可以被 $bx\%p$ 表示出来，而且满足 $x\leqslant p-1$ )

这个最小通解是 $c=\frac{cir\times gcd(b,p)}{gcd(gcd(b,p),cir)}$

然后用 exgcd 求一下 $bx+pk=c$ 的 $x$ 的最小正整数解就可以了.

这里可以证明一下为什么只要存在 $bx+pk=c$ 就能保证 $x<p$：

我们可以将 $x$ 表示成 $p+d$ 的形式，那么原式为 $b(p+d)+pk=c$

$\Rightarrow bp+bd+pk=c$

$\Rightarrow b\times d+p\times (k+d)=c$

所以，一旦 $x>p$，我们就可以将一些部分导到 $p\times k$ 那里，以此来实现 $x<p$

#include <string>
#include <ctime>
#include <cmath>
#include <cstdio>
#include <vector>
#include <algorithm>
#define N 10000060
#define ll long long
using namespace std;
void setIO(string s) {
    string in=s+".in";
    string out=s+".out";
    freopen(in.c_str(),"r",stdin);
    freopen(out.c_str(),"w",stdout);
}
int H=0;
int fr[N];
int prime[N],vis[N],phi[N];
int answer[N];
int MN[N];
struct data {
    int a,b,p,id;
    data(int a=0,int b=0,int p=0,int id=0):a(a),b(b),p(p),id(id){}
};
vector<data>G[N];
inline int qpow(int x,int y,int mod) {
    int tmp=1;
    while(y) {
        if(y&1) {
            tmp=(ll)tmp*x%mod;
        }
        x=(ll)x*x%mod;
        y>>=1;
    }
    return tmp;
}
int exgcd(int a,int b,int &x,int &y) {
    if(!b) {
        x=1,y=0;
        return a;
    }
    int gcd=exgcd(b,a%b,x,y);
    int tmp=x;
    x=y,y=tmp-(a/b)*y;
    return gcd;
}
void Linear_shaker() {
    int i,j,cnt=0;
    fr[1]=1;
    for(i=2;i<N;++i) {
        if(!vis[i]) {
            prime[++cnt]=i;
            phi[i]=i-1;
            fr[i]=1;
        }
        for(j=1;j<=cnt&&prime[j]*i<N;++j) {
            vis[i*prime[j]]=1;
            if(i%prime[j]) {
                phi[i*prime[j]]=phi[i]*(prime[j]-1);
                fr[i*prime[j]]=i;
            }
            else {
                fr[i*prime[j]]=i;
                phi[i*prime[j]]=phi[i]*prime[j];
                break;
            }
        }
    }
}
int main() {
    // setIO("mod");
    Linear_shaker();
    int i=0,j=0,t1,t2,tp=0;
    int a,b,p,Mx=0,k;
    while(scanf("%d",&a)!=EOF) {
        scanf("%d%d",&b,&p);
        ++i;
        ++tp;
        if(__gcd(a,p)!=1) {
            answer[i]=-1;
        }
        else {
            Mx=max(Mx,phi[p]);
            G[phi[p]].push_back(data(a,b,p,i));
            MN[i]=phi[p];
            int w=phi[p],tmp,c=1;
            while(w!=1) {
                while(w!=1&&qpow(a,fr[w]*c,p)==1) {
                    w=fr[w];
                }
                tmp=w/fr[w];
                while(w%tmp==0&&w!=1) {
                    c*=tmp;
                    w/=tmp;
                }
            }
            MN[i]=c;
        }
    }
    for(i=1;i<=Mx;++i) {
        for(j=0;j<G[i].size();++j) {
            a=G[i][j].a;
            b=G[i][j].b;
            p=G[i][j].p;
            int x=0,y=0;
            int id=G[i][j].id;
            int delta=MN[id];
            int gcd=__gcd(p,b);
            int tmp=(1ll*gcd*delta)/(__gcd(gcd,delta));
            if(tmp>=p) {
                answer[id]=-1;
            }
            else {
                gcd=exgcd(b,p,x,y);
                x=(1ll*x*(tmp/gcd)%(p/gcd)+(p/gcd))%(p/gcd);
                answer[id]=x;
            }
        }
    }
    for(i=1;i<=tp;++i) printf("%d\n",answer[i]);
    return 0;
}