关于数论的一些总结

结论：我数论太渣了……

言归正传……先列出几个常用的性质/结论

同余式：

1. da≡db (mod m) 则a≡b (mod m/(m,d) ) （这在取遍剩余系会用到）

2. a≡b (mod m)  m'|m , a≡b (mod m')

3. a≡b (mod mi) i=1..k 等价于 a≡b (mod M) M=[m1,m2,..mk]

一般剩余系：

剩余系就是可能余数组成的集合，简化剩余系也称既约剩余系，是模n的完全剩余系的一个子集，其中每个元素与n互素。

1. 模p的剩余系{rk}，若(p,d)=1那么{d*rk}也是模p的剩余系

这个很重要，如果求ax mod p的既约剩余系的大小，我们只要利用同余式的性质1

转化为x*a/gcd(a,p) mod (p/gcd(a,p))，根据这个理论 x取值个数就是p/gcd(a,p)

2. 设模m1的既约剩余系为R1,m2的既约剩余系为R2，m1m2互质，则模m1m2的既约剩余系为R={x=m2x1+m1x2 (mod m1m2) | x1∈R1,x2∈R2}

这个结论证明可以考虑任意两个x互不同余即可（作差判断）

这就告诉我们一个很厉害的东西 S(M)表示M既约剩余系的大小的话，S(M)=S(m1)*S(m2)

3. 这个结论推广到k维就是,设模mk的既约剩余系为Rk, mk两两互质，M=∏mi 则模M的既约剩余系为R={ ∑M*mi^-1*ai (mod M) | xi∈Ri }  

因此以后我们求模M的剩余系大小，可以对M质因数分解分别求出后再相乘

阶、原根、指标：

 阶（又叫指数）：a,m为互素整数且m>=2 ，则使 a^r≡1(mod m) 成立的最小正整数 r 记为 a 模 m 的指数，记作ord_m(a)

根据欧拉定理，显然ord_m(a)一定是φ(m)的约数

阶有几个性质： 1. ord_m(a)=xy 则 ord_m(a^x)=y 2.ord_m(a)=x, ord_m(b)=y (x,y)=1 则ord_m(ab)=xy;

3. ord_m(a)=t ord_m(a^x)=t/gcd(t,x) （其实就是性质1的变形）

原根：阶中要求(a,m)互素，所以a^x与m互素，所以a^x模m的余数与m互素，这样这个余数只可能有 φ(m) 种不同的取值。

（这里我想到了了一个很有意思的结论：1~n内与n互质的数的和为{n*φ(n)+[n==1]} /2 

这里考虑gcd(i,n)=1，则gcd(n,n-i)=1，证明用反证法即可。）

当满足ord_m(a)=φ(m)的a称作模m的原根，记作g。

这有一个显然的结论若 x=0,1,2,3,...,φ(m)-1，则 g^x 模 m 的余数都和 m 互素，并且模 m 两两不同余。

指标：简单来说，就是一切小于m且与m互质的数r，都存在唯一个数k(k<φ(m))，使得g^k≡r (mod m)

我们就把k叫作r的指标，记作I(r)

这是一个非常有用的性质，之后的题目我们会经常看到他。

指标有这么几个性质：1. I(ab)≡I(a)+I(b) (mod m) 2. I(a^k)≡kI(a) (mod m)

简而言之，指标就像是数论里的取对数。

原根和求指标将在后面的同余方程中起到巨大作用，但是首先我们要知道什么数有原根

直接上结论： 当且仅当m=2,4,p^k,2p^k时才有原根，p是某一奇素数

证明可以看《初等数论及其应用》

还有一个非常有用的定理是：若g是某一奇素数p的原根，那么g也是p^k的原根，证明依然在《初等数论及其应用》

事实上，一个数p的原根的数目为φ(φ(p)) （考虑若g是p的原根，g^u是p的原根当且仅当gcd(u,φ(p))=1）

另外我们注意到2的原根是1，4的原根是3，但其他2次幂是没有原根的（在高次剩余里，模2次幂会带来不小的麻烦）

事实上有一个恒等式：a^φ(xy)/2≡1 (mod xy) (x，y互素且a与xy互素）

在2次幂的时候就有a^(2^k)≡1 (mod 2^k+2) 恒成立，所以2的3次及以上次幂没有原根

（补充一个很有意思的结论：5模2^k+2的指数正好是2^k ）

一个数的原根不止一个，一般就找最小的那个就可以了

其他的原根可用最小原根的g^u表示（g^u是p的原根当且仅当gcd(u,φ(p))=1）

找m的最小原根一般就是暴力枚举g,然后穷举m的每个质因数p，判断g^φ(m)/p≡1 (mod m)是否成立（成立的话就不是原根）

一道找所有原根的题目

#include<bits/stdc++.h>

using namespace std;
typedef long long ll;
int phi[1000010],p[1000010],a[100010],ans[1000010],n,r,t;
bool v[1000010];

int gcd(int a,int b)
{
    return (b==0)?a:gcd(b,a%b);
}

ll quick(ll x,int y,int mo)
{
    ll s=1;
    while (y)
    {
        if (y&1) s=s*x%mo;
        x=x*x%mo;
        y>>=1;
    }
    return s;
}

int check(int n)
{
    if (n%2==0) return -1;
    if (!v[n]) return n;
    for (int i=2; p[i]*p[i]<=n; i++)
        if (n%p[i]==0)
        {
            while (n%p[i]==0) n/=p[i];
            if (n>1) return -1;
            else return p[i];
        }
    return -1;
}

bool work(int g,int mo)
{
    if (gcd(g,mo)!=1) return 0;
    for (int i=1; i<=r; i++)
        if (quick(g,phi[mo]/a[i],mo)==1) return 0;
    return 1;
}

int getg(int mo)
{
    int n=phi[mo];
    r=0;
    for (int i=1; p[i]*p[i]<=n; i++)
        if (n%p[i]==0)
        {
            while (n%p[i]==0) n/=p[i];
            a[++r]=p[i];
        }
    if (n>1) a[++r]=n;
    for (int i=2; i<mo; i++)
        if (work(i,mo)) return i;
}

int main()
{
    phi[1]=1;
    for (int i=2; i<=1000000; i++)
    {
        if (!v[i])
        {
            phi[i]=i-1;
            p[++t]=i;
        }
        for (int j=1; j<=t; j++)
        {
            if (i*p[j]>1000000) break;
            v[i*p[j]]=1;
            if (i%p[j]==0)
            {
                phi[i*p[j]]=phi[i]*p[j];
                break;
            }
            else phi[i*p[j]]=phi[i]*(p[j]-1);
        }
    }
    while (scanf("%d",&n)!=EOF)
    {
        if (n==2)
        {
            puts("1");
            continue;
        }
        if (n==4)
        {
            puts("3");
            continue;
        }
        int ch=(n%2==1)?check(n):check(n/2);
        if (ch==-1)
        {
            puts("-1");
            continue;
        }
        int g=getg(n);
        int l=0;
        for (int i=1; i<=phi[n]; i++)
            if (gcd(i,phi[n])==1) ans[++l]=quick(g,i,n);
        sort(ans+1,ans+1+l);
        for (int i=1; i<=l; i++)
        {
            printf("%d",ans[i]);
            if (i==l) puts(""); else printf(" ");
        }
    }
}

高次同余相关的问题：

高次同余问题一般都会把余数b进行ga≡b (mod p)这样的变化

这样统一底后进行两边取指标，这样就将问题转化为了线性同余问题

比如今年第二场多校的hdu6051，就利用了将高次同余都转化为原根为底的形式

具体题解在：http://bestcoder.hdu.edu.cn/blog/2017-multi-university-training-contest-2-solutions-by-%E7%94%B5%E5%AD%90%E7%A7%91%E6%8A%80%E5%A4%A7%E5%AD%A6/

#include<bits/stdc++.h>

using namespace std;
typedef long long ll;
const int mo=1e9+7;
int m,p;
ll sqr(ll x)
{
    return x*x%mo;
}

void inc(int &a,int b)
{
    a+=b;
    if (a>mo) a-=mo;
}

int phi(int n)
{
    int s=n;
    for (int i=2; i*i<=n; i++)
        if (n%i==0)
        {
            s=s/i*(i-1);
            n/=i;
            while (n%i==0) n/=i;
        }
    if (n>1) s=s/n*(n-1);
    return s;
}

int calc(int n)
{
    if (n==1) return 1;
    return 1ll*n*phi(n)/2%mo;
}

int main()
{
    int cas;
    scanf("%d",&cas);
    for (int tt=1; tt<=cas; tt++)
    {
        scanf("%d%d",&m,&p);
        int ans=0;
        for (int i=1; i*i<=(p-1); i++)
            if ((p-1)%i==0)
            {
                inc(ans,sqr(i)*calc((p-1)/i)%mo);
                int j=(p-1)/i;
                if (j!=i) inc(ans,sqr(j)*calc((p-1)/j)%mo);
            }
        int s=1ll*(p-1)*p/2%mo;
        ans=(ans-s+mo)%mo;
        ans=1ll*ans*m%mo;
        printf("Case #%d: %d
",tt,ans);
    }
}

还有著名的数论之神，题解我是看这的：http://blog.csdn.net/regina8023/article/details/44863519

（可以注意到模数是奇数，也就是不会考虑到2次幂的情况，降低了难度）

#include<bits/stdc++.h>

using namespace std;
typedef long long ll;
const int inf=1e9+7;
int a[100010],A,B,n,t;
map<int,int> mp;
ll quick(ll x,int y,int mo)
{
    ll s=1;
    while (y)
    {
        if (y&1) s=s*x%mo;
        x=x*x%mo;
        y>>=1;
    }
    return s;
}

int gcd(int a,int b)
{
    return (b==0)?a:gcd(b,a%b);
}

int chai(int n,int p)
{
    int s=0;
    while (n%p==0)
    {
        s++;
        n/=p;
    }
    return s;
}

void exgcd(int a, int b, int &x, int &y)
{
     if (!b){x=1; y=0; return;}
     else {
          exgcd(b,a%b,x,y);
          int xx=x, yy=y;
          x=yy; y=xx-a/b*yy;
     }
}

int bsgs(int y,int z,int p)
{
    y%=p; z%=p;
    mp.clear();
    mp[1]=p-1;
    ll m=(int)sqrt(p)+1, now=1;
    for (int i=1; i<=m; i++)
    {
        now=1ll*now*y%p;
        if (!mp[now]) mp[now]=i;
    }
    int g=gcd(now,p);
    if (g!=1) return -1;
    now/=g; int w=p/g,x,k;
    exgcd(now,w,x,k); x=(x+w)%w;
    ll step=z;
    for (int i=0; i<m; i++)
    {
        if (mp[step])
        {
           if (step==1) mp[step]=0;
           return mp[step]+i*m;
        }
        step=step*(ll)x%p;
    }
    return -1;
}

bool check(int g,int p)
{
    for (int i=1; i<=t; i++)
        if (quick(g,(p-1)/a[i],p)==1) return 0;
    return 1;
}

int getg(int p)
{
    t=0; int n=p-1;
    for (int i=2; i*i<=n; i++)
        if (n%i==0)
        {
            a[++t]=i;
            while (n%i==0) n/=i;
        }
    if (n>1) a[++t]=n;
    for (int i=2;;i++)
        if (check(i,p)) return i;
}

int calc(int p,int t,int nw,int B)
{
    if (B==0)
    {
        int s=(t-1)/A+1;
        return quick(p,t-s,inf);
    }
    else {
        int s=chai(B,p),f=1;
        if (s)
        {
            if (s%A!=0) return 0;
            f=quick(p,s-s/A,inf);
            int gg=gcd(nw,B);
            nw/=gg; B/=gg;
        }
        int phi=nw/p*(p-1);
        int nb=bsgs(getg(p),B,nw);
        if (nb==-1) return 0;
        int gg=gcd(phi,A);
        if (nb%gg) return 0;
        return f*gg;
    }
}

int main()
{
    int cas;
    scanf("%d",&cas);
    while (cas--)
    {
        scanf("%d%d%d",&A,&B,&n);
        n=2*n+1; B%=n;
        int ans=1;
        for (int i=2; i*i<=n; i++)
            if (n%i==0)
            {
                int s=0,nw=1;
                while (n%i==0)
                {
                    s++; nw*=i;
                    n/=i;
                }
                ans*=calc(i,s,nw,B%nw);
                if (!ans) break;
            }
        if (n>1) ans*=calc(n,1,n,B%n);
        printf("%d
",ans);
    }
}

前面的几题是高次同余方程的问题，那么高次剩余系的问题呢

下面我觉得是一道最具有代表性的题目：gym101177H 

这是South Pacific Regionals 2016的题目，就是求(x^a+q) mod n的余数的种类数（显然q是卖萌的）

由之前剩余系的基本性质，只要求x^a mod pi^ki 的余数种类数，然后求积就可以了

这要分情况，假如pi是奇素数，那么pi^ki是有原根的，假设为g，我们不妨先考虑与pi^ki互质的x可能的余数

令g^w≡x (mod pi^ki) 由之前原根的性质，这样就是求wa mod φ(pi^ki)可能的余数个数

显然这个个数就是 φ(pi^ki)/gcd( φ(pi^ki)，a)

而与 pi^ki不互质的x余数的种类数，我们只要枚举x包含pi的几次幂为因数，设x=q*pi^ei

问题就是转化为x^a mod pi^ki-a*ei且x与pi互质的情况了

难点在于考虑p=2的情况，因为除了2,4，p不存在原根，这怎么考虑呢

还是想刚才一样分x为奇偶考虑（偶数是类似之前处理）

注意到当a为奇数的时候，所有一共2^k-1个奇数都是可能的余数

证明的话考虑任意两个奇数x1,x2，x1^a-x2^a=(x1-x2)(x1^a-1+x1^p-2x2+...+x2^p-1)

前一项是偶数但是一定小于2^k，后一项是奇数，因此x1^a-x2^a模2^k不同余，余数自然可以取到2^k-1个奇数

下面考虑a为偶数的情况，显然a可以表示a=q*2^e   （q为奇数）

由之前a为奇数的情况我们知道x^q 相当于把所有奇数做了一个置换，因此我们只要考虑x^(2^e) mod 2^k可能的余数

这有点二次剩余的味道，首先很明显x²和(2^k-x)²一定是mod 2^k同余的

进一步观察我们会发现x²和(2^k-1-x)²也是mod 2^k同余的，就是当e=1时，只能取2^k-3

之后e每增加1，也就是多一个平方，就会使两两一组奇数变为同余，所以答案为2^k-2-e

问题得解，撒花

#include<bits/stdc++.h>

using namespace std;
int k,q,n;
int quick(int x,int y)
{
    int s=1;
    while (y)
    {
        if (y&1) s=s*x;
        x=x*x;
        y>>=1;
    }
    return s;
}

int gcd(int a,int b)
{
    return (b==0)?a:gcd(b,a%b);
}

int calc(int p,int x)
{
    if (x<=0) return 1;
    if (p>2)
    {
        int phi=quick(p,x-1)*(p-1);
        int s=phi/gcd(phi,k);
        s+=calc(p,x-k);
        return s;
    }
    if (x==1) return 2;
    int phi=quick(2,x-2);
    int s=phi/gcd(phi,k);
    if (k%2==1) s*=2;
    s+=calc(p,x-k);
    return s;
}

int main()
{
    scanf("%d%d%d",&k,&q,&n);
    if (k==1)
    {
        printf("%d
",n);
        return 0;
    }
    int ans=1;
    for (int i=2; 1ll*i*i<=n; i++)
        if (n%i==0)
        {
            int s=0;
            while (n%i==0)
            {
                n/=i;
                ++s;
            }
            ans*=calc(i,s);
        }
    if (n>1) ans*=calc(n,1);
    printf("%d
",ans);
}

上面那个问题让我想到一个非常有意思的东西叫二次剩余

就是说x²≡b (mod p)有解，就把b叫作p的二次剩余

如果我们定义(a/p)=1 （a是p的二次剩余） 或 -1（a不是p的二次剩余）

那么有一个非常有意思的定理（欧拉判别法）是(a/p)≡a^(p-1)/2 (mod p) p是奇素数 a不被p整除

由此可以退出还有二次剩余乘二次剩余一定是二次剩余，二次剩余乘非二次剩余是非二次剩余，非二次剩余乘非二次剩余是二次剩余

还有一个著名的二次互反律：设p，q为奇素数

(q/p)(p/q)=(-1)^(p-1)(q-1)/4 就是由q是p的二次剩余如何快速判断p是q的二次剩余

如果把二次剩余的结论推广到n次，则是这样的（但似乎没有类似高次互反律的东西）

前提：p是奇质数且p不能整除d，判定xⁿ≡d (mod p)是否有解

1.若n|(p-1)（即n能整除p-1），则d是模p的n次剩余的充要条件为：d^(p-1)/n≡1(mod p)且有解时，解数为n。
2.若n不能整除p-1，则d是模p的n次剩余的充要条件为：d^(p-1)/k≡1(mod p)，其中k=(n,p-1)，且有解时解数为k。

感觉关于二次剩余和二次互反律的题目还不多，就先写到这吧

最后补一个扩展BSGS的模板吧

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<map>

using namespace std;
typedef long long ll;
int A,p,B;
map<int,int> mp;

int gcd(int a,int b)
{
    return (b==0)?a:gcd(b,a%b);
}

ll quick(ll x,int y,int mo)
{
    ll s=1;
    while (y)
    {
        if (y&1) s=s*x%mo;
        x=x*x%mo;
        y>>=1;
    }
    return s;
}

void exgcd(int a, int b, int &x, int &y)
{
     if (!b){x=1; y=0; return;}
     else {
          exgcd(b,a%b,x,y);
          int xx=x, yy=y;
          x=yy; y=xx-a/b*yy;
     }
}

int inv(int a,int p)
{
    int g=gcd(a,p);
    if (g!=1) return -1;
    a/=g; int w=p/g,x,k;
    exgcd(a,w,x,k); x=(x+w)%w;
    return x;
}

int bsgs(int y,int z,int p)
{
    y%=p;
    mp.clear();
    mp[1]=p-1;
    ll m=(int)sqrt(p)+1, now=1;
    for (int i=1; i<=m; i++)
    {
        now=now*(ll)y%p;
        if (!mp[now]) mp[now]=i;
    }
    int x=inv(now,p);
    if (x==-1) return -1;
    ll step=z;
    for (int i=0; i<m; i++)
    {
        if (mp[step])
        {
           if (step==1) mp[step]=0;
           return mp[step]+i*m;
        }
        step=1ll*step*x%p;
    }
    return -1;
}

int ext(int a,int b,int p)
{
    if (b==1) return 0;
    ll t=gcd(a,p),d=1,k=0;
    while (t!=1)
    {
        if (b%t) return -1;
        ++k,b/=t,p/=t, d=d*(a/t)%p;
        if (b==d) return k;
        t=gcd(a,p);
    }
    b=1ll*b*inv(d,p)%p;
    int s=bsgs(a,b,p);
    if (s==-1) return -1;
    else return s+k;
}

int main()
{
    while (scanf("%d%d%d",&A,&p,&B)!=EOF)
    {
        if (!A&&!p&&!B) break;
        int ans=ext(A,B,p);
        if (ans==-1) puts("No Solution");
        else printf("%d
",ans);
    }
}