2417 Discrete Logging 计算最小的x使得a^x=b(mod n) n是素数 Baby_step_Giant_step

最新推荐文章于 2022-06-09 08:48:42 发布

原创最新推荐文章于 2022-06-09 08:48:42 发布 · 880 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#logging #integer #numbers #search #input #each

acm_数学问题专栏收录该内容

163 篇文章

订阅专栏

本文介绍了一种解决离散对数问题的有效算法——Baby Step Giant Step算法，并提供了详细的实现代码。该算法用于计算特定条件下基底的离散对数，通过预处理和查找表的方式减少计算复杂度。

Discrete Logging

Time Limit: 5000MS		Memory Limit: 65536K
Total Submissions: 1431		Accepted: 709

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

Hint

The solution to this problem requires a well known result in number theory that is probably expected of you for Putnam but not ACM competitions. It is Fermat's theorem that states

   B^(P-1) == 1 (mod P)

for any prime P and some other (fairly rare) numbers known as base-B pseudoprimes. A rarer subset of the base-B pseudoprimes, known as Carmichael numbers, are pseudoprimes for every base between 2 and P-1. A corollary to Fermat's theorem is that for any m

   B^(-m) == B^(P-1-m) (mod P) .

#include<iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
using namespace std;
struct Node
{
    int index;//序号
    __int64 val;//值
};
Node num[66000];
__int64 gcd(__int64 a,__int64 b)
{
    return b==0?a:gcd(b,a%b);
}
__int64 _pow(__int64 a,__int64 b,__int64 m)
{
    if(b==0) return 1;
    if(b==1) return a%m;
    __int64 t=_pow(a,b/2,m);
    t=(t*t)%m;
    if(b&1) t=(t*a)%m;
    return t;
}
bool cmp(Node h,Node k)
{
    if(h.val!=k.val) return h.val<k.val;
    return h.index<k.index;
}
int _binary_search(__int64 key,__int64 len)//二分查找
{
    int left = 0,right = len;
    int result = - 1,mid;
    while(left <= right)
    {
        mid = (left + right)>>1;
        if(num[mid].val == key)
        {
            result = num[mid].index;
            right = mid -1;
        }
        else if(num[mid].val < key)  left = mid + 1;
        else   right = mid -1;
    }
return result;
}
int Baby_step_Giant_step(__int64 a,__int64 b,__int64 n)//计算最小的x使得a^x=b(mod n) n是素数
{
    __int64 m=(__int64)(sqrt(n+0.5)+1);
    //计算 (j,a^j%n) (0<=j<m)
    num[0].index=0,num[0].val=1;
    for(int i=1;i<m;i++) num[i].index=i,num[i].val=num[i-1].val*a%n;
    sort(num,num+m,cmp);

    //计算 a^-m
    __int64 a_m=_pow(a,n-1-m,n);//因为n是素数,所以a^(n-1)=1(mod n)
    __int64 y=b;
    for(int i=0;i<m;i++)
    {
        int res=_binary_search(y,m);
        if(res!=-1) return i*m+res;
        y=y*a_m%n;
    }
    return -1;
}
int main()
{
    __int64 n,a,b;//a^x=b(mod n)
    while(scanf("%I64d%I64d%I64d",&n,&a,&b)==3&&(n||a||b))
    {
        int r = Baby_step_Giant_step(a,b,n);
        if(r == -1)
            printf("no solution/n");
        else
        printf("%d/n",r);
    }
    return 0;
}