BZOJ2219: 数论之神

原来BSGS是可以省掉那个log的…

---

---

这题要分类讨论，用到几个重要的结论（并不是很能理解这些结论）
1：中国剩余定理的推论：几个模数互质的同余方程组合起来，解的个数是各方程解的个数的乘积
2：拓展欧几里得的推论：$Ax\equiv B (mod\ C)$，$d=gcd(A,C)$，若$d|B$则方程有解，解的数量为 d <script type="math/tex" id="MathJax-Element-422">d</script>

模数不为质数时把模数分解质因数，拆分成多个方程，然后CRT
解和指数有关的东西不知道怎么办，把指数拉下来（就是找到原根，弄出指标），然后就可以解了

其实我完全不知道这题题解该怎么写，也不打算写毕竟自己理解也不深，这是道好题，值得多做几次，我给几个写的好的题解吧：

Orz jcvb
Orz PoPoQQQ
这篇我觉得写的也不错

---

---

code：

#include<set>
#include<map>
#include<deque>
#include<queue>
#include<stack>
#include<cmath>
#include<ctime>
#include<bitset>
#include<string>
#include<vector>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<climits>
#include<complex>
#include<iostream>
#include<algorithm>
#define ll long long
using namespace std;

const int maxn = 110000;
const int maxh = (1<<18)-1;

int gcd(int a,int b){return a==0?b:gcd(b%a,a);}
int exgcd(int a,int b,ll &x,ll &y)
{
    if(a==0)
    {
        x=0; y=1;
        return b;
    }
    ll tx,ty;
    int d=exgcd(b%a,a,tx,ty);
    x=ty-b/a*tx;
    y=tx;
    return d;
}
ll Ni(ll x,ll mod)
{
    ll tx,ty,d;
    d=exgcd(x,mod,tx,ty);
    return (tx%mod+mod)%mod;
}
ll pw(ll x,int k,ll mod)
{
    x%=mod;
    ll ret=1,tmp=x;
    while(k)
    {
        if(k&1)ret=ret*tmp%mod;
        tmp=tmp*tmp%mod;
        k>>=1;
    }
    return ret;
}
int p[maxn],pri;
bool v[maxn];
void get_prime()
{
    for(int i=2;i<maxn;i++)
    {
        if(!v[i]) p[++pri]=i;
        for(int j=1;j<=pri&&i*p[j]<maxn;j++)
        {
            int k=i*p[j];
            v[k]=true;
            if(i%p[j]==0) break;
        }
    }
}
void Divide(int *pr,int &len,int P)
{
    len=0;
    for(int i=1;p[i]*p[i]<=P;i++)
    {
        if(P%p[i]==0)
        {
            P/=p[i];
            pr[++len]=p[i];
            while(P%p[i]==0) P/=p[i];
        }
    }
    if(P!=1) pr[++len]=P;
}
int pr[maxn],len;
int get_g(ll P,int tphi)
{
    Divide(pr,len,tphi);
    for(ll i=2;i<=P;i++)
    {
        bool flag=true;
        for(int j=1;j<=len;j++)
        {
            ll tt=tphi/pr[j];
            if(pw(i,tt,P)==1) {flag=false; break;}
        }
        if(flag) return i;
    }
}
struct H
{
    int i,t,x,nex;
    H(){t=0;}
    H(int _i,int _t,int _x,int _nex){i=_i;t=_t;x=_x;nex=_nex;}
}hash[maxh<<3]; int cnt;
int times;
void ins(int x,int id)
{
    int k=x&maxh;
    if(hash[k].t!=times){ hash[k]=H(id,times,x,-1); return ;}
    int i,pos;
    for(i=k;i!=-1;pos=i,i=hash[i].nex)
    {
        if(hash[i].t!=times) break;
        if(hash[i].x==x) return ;
    }
    hash[pos].nex=++cnt; hash[cnt]=H(id,times,x,-1);
}
int find_(int x)
{
    int k=x&maxh;
    for(int i=k;i!=-1&&hash[i].t==times;i=hash[i].nex)
        if(hash[i].x==x) return hash[i].i;
    return -1;
}
int BSGS(ll x,ll b,ll P)
{
    times++; cnt=maxh;
    int M=(int)(ceil(sqrt(P)));
    ll t=1;
    for(int i=0;i<M;i++,t=t*x%P) ins(t,i);
    ins(t,M); t=Ni(t,P);
    ll now=b;
    for(int i=0;i<M;i++,now=now*t%P)
    {
        ll tt=find_(now);
        if(tt!=-1)return i*M+tt;
    }
    return -1;
}
int solve(int A,ll B,ll pi,ll P,int num)
{
    B%=P;
    if(!B)
    {
        int k=(num-1)/A+1;
        return pw(pi,num-k,P);
    }
    ll ret=1;
    if(gcd(B,P)!=1)
    {
        int d=0;
        while(B%pi==0) d++, B/=pi;
        if(d%A) return 0;
        ret*=pw(pi,d-d/A,P);
        for(int i=1;i<=d;i++) P/=pi,num--;
    }
    int tphi=P-P/pi;
    ll g=get_g(P,tphi);
    ll bi=BSGS(g,B,P); if(bi==-1)return 0;
    ll D=gcd(A,tphi);
    if(bi%D) return 0;
    return ret*D;
}

int main()
{
    get_prime();
    int t; scanf("%d",&t);
    while(t--)
    {
        int n,m,P; scanf("%d%d%d",&n,&m,&P); P=2*P+1;
        int ret=1,tp,tnum;
        for(int i=1;p[i]*p[i]<=P&&i<=pri;i++)if(P%p[i]==0)
            {
                P/=p[i]; tp=p[i]; tnum=1;
                while(P%p[i]==0) P/=p[i],tp*=p[i],tnum++;
                ret*=solve(n,m,p[i],tp,tnum);
                if(!ret)break;
            }
        if(P!=1) ret*=solve(n,m,P,P,1);
        printf("%d\n",ret);
    }

    return 0;
}