hdu 2815 Mod Tree

http://acm.hdu.edu.cn/showproblem.php?pid=2815

　　题意很简单，转换过来，就是要求满足K^x mod P = N的最小X。

　　这是专业版的Baby-Step Giant-Step，相对之前那个hdu 1395的BSGS的用途广泛的多。这里的算法可以解决当底数与模非互质的时候，满足条件的X的最小值。

　　BSGS粗略的说，就是像我前两篇随笔的解释一样。不过，实际解决问题的时候，如果底数与模不是互质，那么exgcd求AX mod B = C中，X的解并不正确。因此，在该过程前，要将式子中的A与B互质，从而解出唯一解！使得两者互质的过程如下：

while((tmp=gcd(A，B))!=1){

　　if(B％tmp)return -1; // 无解!

　　++d;

　　B/=tmp;

　　C/=tmp;

　　D=D*A/tmp％C;

}

　　这个消因子的步骤十分关键，详细的解释点击链接，里面有这个过程的证明，我就不一一叙述了。

　　这次的代码中间有部分思路不太清晰，所以写得有点乱：

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

using namespace std;
typedef __int64 ll;

//map<int, int> EP;

const int maxn = 500007;
int hash[maxn], EP[maxn];

bool insert(int x, int k){
    int p = (x << 6) % maxn;

    if (p < 0) p += maxn;
    while (hash[p] != x && ~EP[p]) p = (p + 1) % maxn;

    if (hash[p] == x && ~EP[p]) return false;

    hash[p] = x;
    EP[p] = k;

    return true;
}

int find(int x){
    int p = (x << 6) % maxn;

    if (p < 0) p += maxn;
    while (hash[p] != x && ~EP[p]) p = (p + 1) % maxn;

    return EP[p];
}

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

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

int multiMod(int a, int b, int m){
    int ret = 0;

    while (b){
        if (b & 1) ret += a, ret %= m;
        a <<= 1;
        a %= m;
        b >>= 1;
    }

    return ret;
}

int powMod(int p, int n, int m){
    int ret = 1;

    while (n){
        if (n & 1) ret = multiMod(ret, p, m);
        p = multiMod(p, p, m);
        n >>= 1;
    }

    return ret;
}

int babyStep(int &p, int &m, int &rest, int &cnt, int &mark){
    int t, cur = 1 % m;
    int tp = p, tm = m, trest = rest;

    cnt = 0;
//    EP.clear();
    memset(EP, -1, sizeof(EP));
    while ((t = gcd(p, m)) != 1){
        if (cur == rest) return 0;
        if (rest % t) return -1;
        cnt++;
        m /= t;
        rest /= t;
        cur = multiMod(cur, p / t, m);
    }
    mark = cur;
    cur = 1 % tm;
    for (int i = 0; i <= cnt; i++){
        if (cur == trest){
            cnt = i;
            return 0;
        }
        cur = multiMod(cur, tp, tm);
    }
    cur = 1 % m;

    int r = (int) ceil(sqrt((double) m));

    for (int i = 0; i <= r; i++){
//        if (EP.count(cur)) break;
//        EP[cur] = i;
        if (!insert(cur, i)) break;
        cur = multiMod(cur, p, m);
    }

    return r;
}

int giantStep(int p, int m, int rest){
    int tmp, cnt;

    if (rest >= m) return -1;

    int r = babyStep(p, m, rest, cnt, tmp);

    if (r == -1) return -1;

    int ep = powMod(p, r, m);

    if (!r)    return cnt;
    for (int i = 0; i < r; i++){
        ll x, y;

        exgcd(tmp, m, x, y);
        x %= m;
        x *= rest;
        x %= m;
        if (x < 0) x += m;
//        if (EP.count((int)x)){
//            return EP[(int)x] + i * r + cnt;
//        }
        int f = find((int)x);

        if (~f) return f + i * r + cnt;
        tmp = multiMod(tmp, ep, m);
    }

    return -1;
}

int main(){
    int k, p, n;

    while (~scanf("%d%d%d", &k, &p, &n)){
        int ans = giantStep(k, p, n);

        if (~ans) printf("%d\n", ans);
        else puts("Orz,I can’t find D!");
    }

    return 0;
}

——written by Lyon