POJ 3243 Clever Y（离散对数-拓展小步大步算法）

Description

Little Y finds there is a very interesting formula in mathematics:

X^Y mod Z = K

Given X, Y, Z, we all know how to figure out K fast. However, given X, Z, K, could you figure out Y fast?

Input

Input data consists of no more than 20 test cases. For each test case, there would be only one line containing 3 integers X, Z, K (0 ≤ X, Z, K ≤ 10⁹). 
Input file ends with 3 zeros separated by spaces. 

Output

For each test case output one line. Write "No Solution" (without quotes) if you cannot find a feasible Y (0 ≤ Y < Z). Otherwise output the minimum Y you find.

 

题目大意：求离散对数。没有保证Z一定是素数。

思路：http://blog.csdn.net/ivan_zjj/article/details/7597109

PS：说一下上面没有提到的一个东西，最后一个O(sqrt(m))的循环中，逆元是没有必要每次都求的，可以预先求出来，让算法复杂度降至O(sqrt(m))。

在我的代码中，v = k^(-1) * a^(-i*m)，可以在前面先求出k^(-1)和a^(-m)，然后每次v都乘以a^(-m)，而不需要每次对k*a^(i*m)求逆元。

 

代码（63MS）：

 #include <cstdio>
 #include <iostream>
 #include <algorithm>
 #include <cstring>
 #include <cmath>
 using namespace std;
 typedef long long LL;

 const int SIZEH = ;

 struct hash_map {
     int head[SIZEH], size;
     int next[SIZEH];
     LL state[SIZEH], val[SIZEH];

     void init() {
         memset(head, -, sizeof(head));
         size = ;
     }

     void insert(LL st, LL sv) {
         LL h = st % SIZEH;
         for(int p = head[h]; ~p; p = next[p])
             if(state[p] == st) return ;
         state[size] = st; val[size] = sv;
         next[size] = head[h]; head[h] = size++;
     }

     LL find(LL st) {
         LL h = st % SIZEH;
         for(int p = head[h]; ~p; p = next[p])
             if(state[p] == st) return val[p];
         return -;
     }
 } hashmap;

 void exgcd(LL a, LL b, LL &x, LL &y) {
     if(!b) x = , y = ;
     else {
         exgcd(b, a % b, y, x);
         y -= x * (a / b);
     }
 }

 LL inv(LL a, LL n) {
     LL x, y;
     exgcd(a, n, x, y);
     return (x + n) % n;
 }

 LL pow_mod(LL x, LL p, LL n) {
     LL ret = ;
     while(p) {
         if(p & ) ret = (ret * x) % n;
         x = (x * x) % n;
         p >>= ;
     }
     return ret;
 }

 LL BabyStep_GiantStep(LL a, LL b, LL n) {
     for(LL i = , e = ; i <= ; ++i) {
         if(e == b) return i;
         e = (e * a) % n;
     }
     LL k = , cnt = ;
     while(true) {
         LL t = __gcd(a, n);
         if(t == ) break;
         if(b % t != ) return -;
         n /= t; b /= t; k = (k * a / t) % n;
         ++cnt;
     }
     hashmap.init();
     hashmap.insert(, );
     LL e = , m = LL(ceil(sqrt(n + 0.5)));
     for(int i = ; i < m; ++i) {
         e = (e * a) % n;
         hashmap.insert(e, i);
     }
     LL p = inv(pow_mod(a, m, n), n), v = inv(k, n);
     for(int i = ; i < m; ++i) {
         LL t = hashmap.find((b * v) % n);
         if(t != -) return i * m + t + cnt;
         v = (v * p) % n;
     }
     return -;
 }

 int main() {
     LL x, z, k;
     while(cin>>x>>z>>k) {
         if(x ==  && z ==  && k == ) break;
         LL ans = BabyStep_GiantStep(x % z, k % z, z);
         if(ans == -) puts("No Solution");
         else cout<<ans<<endl;
     }
 }