BSGS入门

做了这么长时间数论 应该整合一下

在mod意义下 我们能完成的运算:

加

减(mod m + m mod m) 

快速幂 快速乘

逆元(除) 有有解的条件

开方? 这个设计原根的知识 下一篇讲

然后 就是取对数了 也就是著名的 离散对数 问题

(话说连续对数还不太熟练呢.....)

Question:  给定方程  a ^ x ≡ b (mod c) 求x

Solution:

首先可以容斥地发现 如果有解 0~c范围内一定有一个解

所以枚举! O(c)即可通过本题!

End.

(啪!)

大部分情况下模数都是1e9+7这样的东西 所以枚举显然是过不去的

由于连续情况下 我们并不能高效的得出某一个对数的具体值

所以枚举的思路依然要保留

我们发现其实上面的算法有一个很小的思路优化 :  枚举0~c-1的每个数

也就是说 这里面的每个数 都代表了一类数

(虽然并不是剩余系)

所以我们考虑 能不能先算出一部分答案 然后利用这些答案去简化别的答案的运算

于是! Baby-step giant-step 思想就诞生了

Baby_step,giant_step,意为先小步,后大步,这是一个很神奇的想法。

能够降低枚举的规模从 n 到 sqrt(n),怎么实现的呢,我们看下面。

sqrt(n) -> 考虑分块 (记块大小为B)

然后我们发现 每个块的大小恒定 所以可以拆分成i=x*B+y的形式

我们先O(sqrt(n)) 处理0~B-1的答案 

如果没有找到就存HASH表里

然后O(sqrt(n)) 遍历所有块同时O(1)查找有没有答案

然后就OK

但是有一个问题

这里必须保证把a^i除到b那边以后没有问题

也就是a 有 mod c 的逆元 

所以我们可以一直求gcd(a,c) 然后除掉并且每次拿一个a出来(++tot)

最后答案加上tot就OK

Code:

#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
#define ms(a,b) memset(a,b,sizeof a)
#define inf 2147483647
#define itn int
#define rep(i,a,n) for(itn i = a;i <= n;i++)
#define per(i,n,a) for(itn i = n;i >= a;i--)
#define eps 1e-8
using namespace std;
typedef long long ll;
const int N = 50005;
//head
int X,Z,K;
ll gcd(ll a,ll b){return b ? gcd(b,a%b) : a;}
ll exgcd(ll a,ll b,ll &x,ll &y) {
    if(!b) {
    x = 1,y = 0;
    return a;
    }
    ll t = exgcd(b,a%b,y,x);
    y -= (a/b) * x;
    return t;
}

ll inv(ll a,ll p) {
    ll x,y;
    exgcd(a,p,x,y);
    return (x%p+p)%p;
}

struct Hash {
    const static int H = 999979;
    int head[H],nxt[N],num[N],val[N],cnt;
    void init() {
    cnt = 0;
    ms(head,0),ms(nxt,0),ms(val,0);
    }
    void ins(int x,int y) {
    int h = x % H;
    for(int i = head[h];i;i = nxt[i]) {
        if(num[i] == x) {val[i] = y;return;}
    }
    nxt[++cnt] = head[h];
    head[h] = cnt;
    num[cnt] = x,val[cnt] = y;
    }
    int qry(int x) {
    int h = x % H;
    for(int i = head[h];i;i = nxt[i]) {
        if(num[i] == x) return val[i];
    }
    return -1;
    }
}HASH;

//a ^ x == b(mod p)
int BSGS(int a,int b,int p) {
// gcd(a,p) <- 1
    int tot = 0,G;
    int d = 1;
    while( (G = gcd(a,p)) ^ 1 ) {
    if(b%G) return -1;
    tot++;
    b /= G,p /= G;
    d = (ll)d * (a/G) % p;
    }
    b = (ll)b * inv(d,p) % p;

// ins(a^(0~B-1))
    HASH.init();
    int B = sqrt(p);
    int x = 1;
    rep(i,0,B-1) {
    if(x == b) return i + tot;
    HASH.ins((ll)x * b % p,i);
    x = (ll)x * a % p;
    }

//a^im = b * a^(-y)
//O(B) + O(hash)
    int q = x;
    for(int i = B;i - (B-1) <= p-1;i += B) {
    int tmp = HASH.qry(q);
    if(tmp != -1) return i - tmp + tot;
    q = (ll)q * x % p;
    }
    return -1;
}

bool spj() {
    if(X == 0) {
    puts("No Solution");
    return 1;
    }
    int res = 1;
    rep(i,0,10) {
    if(res == K) {
        printf("%d
",i);
        return 1;
    }
    res = (ll)res * X % Z;
    }
    return 0;
}

//x ^ y == k(mod z)
main() {
    while(~scanf("%d%d%d",&X,&Z,&K)) {
    if(!X && !Z && !K) return 0;
    X %= Z;K %= Z;
    if(spj()) continue;
    int ans = BSGS(X,K,Z);
    if(ans == -1) puts("No Solution");
    else printf("%d
",ans);
    }
}