poj 2417 Discrete Logging ---高次同余第一种类型。babystep_gaint_step

Discrete Logging

Time Limit: 5000MS		Memory Limit: 65536K
Total Submissions: 2831		Accepted: 1391

Description

Given a prime P, 2 <= P < 2³¹, an integer B, 2 <= B < P, and an integer N, 1 <= N < P, compute the discrete logarithm of N, base B, modulo P. That is, find an integer L such that 

B^L == N (mod P)

Input

Read several lines of input, each containing P,B,N separated by a space.

Output

For each line print the logarithm on a separate line. If there are several, print the smallest; if there is none, print "no solution".

Sample Input

5 2 1
5 2 2
5 2 3
5 2 4
5 3 1
5 3 2
5 3 3
5 3 4
5 4 1
5 4 2
5 4 3
5 4 4
12345701 2 1111111
1111111121 65537 1111111111

Sample Output

0
1
3
2
0
3
1
2
0
no solution
no solution
1
9584351
462803587

 

经典的高次同余，C是质数，那么A,C互质。A^x = B(mod C)

 /*

 模板题baby_step.
 Hash + 扩展欧几里得 +拆分思想

 题意：
 求A^x = B( mod C )的最小x，其中C是一个质数。
 思路：
 用普通的babystep_gaint_step即可，具体的做法是这样的，我们把x写成下面这样
 的形式：x = i * m + j ， 这样上式就可以变成：A^m^i * A^j = B( mod C )，其中m=
 ceil( sqrt(C) )，0<=i<m , 0<=j <m，接下去我们先求出所有的A^j % C的值，并且把
 它们存到一个hash表中去，接下去就是先处理出A^m%C的值，记作D,现在上式就
 变成了这样：D^i * A^j = B( mod C )， 现在我们从0-m-1枚举i，这样D^i的值就
 已经知道了，记为DD，下面我们先令A^j 为x，式子就变成了：DD*x = B( mod C )
 这个式子是可以通过普通的扩展欧几里得算法求出x的解的（这个方程的x在0-C
 内一定会只有一个唯一的解，因为gcd(DD, C) == 1， C是质数），然后在建好的hash
 表中查找这个x是否存在，若是存在，则输出此时的i*m+j，就是答案。下面说明一下，
 为什么x只需要考虑0-C的解就可以了，如果解存在，则上面已经说明，一定会在0-
 C范围内存在一个解，因为是找最小的解，因此这时候的解就是答案；如果不存在
 解，我们下面将要说明只需要考虑0-C范围内无解，方程就不会有解了。证明的过程
 大致是这样的，首先如果方程在0 -- C内都没有解， 考虑A^x%C的值，由鸽笼原理可
 知，余数中势必要出现循环节，而且循环节的长度是C的欧拉函数值，也就是说接下
 去的x的余数将进入一个循环，从而将不会得出解了。

 */

 #include<iostream>
 #include<cstdio>
 #include<cstdlib>
 #include<cstring>
 #include<math.h>
 using namespace std;

 typedef __int64 LL;
 const int MAX=;
 LL A,B,C;
 bool Hash[MAX];
 LL idx[MAX];
 LL val[MAX];

 void Ex_gcd(LL a,LL b,LL &x,LL &y)
 {
     if(b==)
     {
         x=;
         y=;
         return ;
     }
     Ex_gcd(b,a%b,x,y);
     LL hxl=x-(a/b)*y;
     x=y;
     y=hxl;
 }

 LL Euler(LL n)
 {
     LL i,temp=n;
     for(i=;i*i<=n;i++)
     {
         if(n%i==)
         {
             while(n%i==)
             n=n/i;
             temp=temp/i*(i-);
         }
     }
     if(n!=)
     temp=temp/n*(n-);
     return temp;
 }

 void Insert(LL id,LL num)
 {
     LL k=num%MAX;
     while(Hash[k] && val[k]!=num)
     {
         k++;
         if(k==MAX) k=k-MAX;
     }
     if(!Hash[k])
     {
         Hash[k]=;
         idx[k]=id;
         val[k]=num;
     }
 }// Hash make

 LL found(LL num)
 {
     LL k=num%MAX;
     while(Hash[k] && val[k]!=num)
     {
         k++;
         if(k==MAX) k=k-MAX;
     }
     if(!Hash[k])
     {
         return -;
     }
     return idx[k];
 }// Hash find

 LL baby_step(LL a,LL b,LL c)
 {
     LL M=ceil(sqrt(Euler(c)*1.0));
     memset(Hash,false,sizeof(Hash));
     memset(idx,-,sizeof(idx));
     memset(val,-,sizeof(val));
     LL D=;
     for(LL i=;i<M;i++)
     {
         Insert(i,D);
         D=D*a%c;
     }//maek D;

     LL res=;
     LL x,y;
     for(LL i=;i<M;i++)
     {
         Ex_gcd(res,c,x,y);
         LL tmp=x*b%c;
         tmp=(tmp%c +c)%c;
         LL k=found(tmp);
         if(k!=-)
         {
             return LL(i)*M+k;
         }
         res=res*D%c;
     }
     return -;
 }

 int main()
 {
     while(scanf("%I64d%I64d%I64d",&C,&A,&B)>)
     {
         LL res=baby_step(A,B,C);
         if(res==-)
         {
             printf("no solution\n");
         }
         else printf("%I64d\n",res);
     }
     return ;
 }