Discrete Logging

最新推荐文章于 2019-08-03 16:59:00 发布

XY20130630

最新推荐文章于 2019-08-03 16:59:00 发布

阅读量400

点赞数

分类专栏：题解数学 POJ

本文链接：https://blog.youkuaiyun.com/XY20130630/article/details/51691256

版权

题解同时被 3 个专栏收录

186 篇文章

订阅专栏

数学

45 篇文章

订阅专栏

POJ

3 篇文章

订阅专栏

本文介绍了一种解决离散对数问题的方法，并通过Baby Step Giant Step算法实现。该算法利用哈希表来提高计算效率，对于特定的输入参数（素数P、底数B及目标N），能够找到最小的整数L，使得B的L次方模P等于N。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目地址请点击——

Discrete Logging

Description

Given a prime $P$ , $2 \leq P < 2^{31}$ , an integer $B$ , $2 \leq B < P$ , and an integer $N$ , $1 \leq N < P$ , compute the discrete logarithm of $N$ , base $B$ , modulo $P$ .
That is , find an integer $L$ such that

B L \equiv N (m o d P)

$B^L \equiv 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 \equiv 1 (m o d P)

$B^{P-1} \equiv 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 \equiv B P - 1 - m (m o d P)

$B^{-m} \equiv B^{P-1-m}\ (mod\ P)$ .

Source

Waterloo Local 2002.01.26

Solution

Baby Step Giant Step 算法的模板题。

Code

#include <iostream>
#include <cstdio>
#include <cmath>

#define LL long long
#define HASH_MOD 786433

using namespace std;

LL p,b,n,ans;
LL fx,fy;

struct map{
    LL h[800000],v[800000],nxt[800000],ne[800000];
    void clear(){
        memset(nxt,-1,sizeof nxt);
        memset(h,-1,sizeof h);
        ne[786433]=0;
        for(LL i=0;i<786433;i++)ne[i]=i;
    }
    LL fi(LL x){
        LL tmp=x,pre;
        while(tmp!=ne[tmp])tmp=ne[tmp];
        while(x!=tmp){pre=ne[x];ne[x]=tmp;x=pre;}
        return tmp;
    }
    void insert(LL x,LL y){
        LL mx=x%HASH_MOD;
        while(nxt[mx]!=-1)
            mx=nxt[mx];
        nxt[mx]=fi(0);
        ne[nxt[mx]]=ne[nxt[mx]]+1;
        h[nxt[mx]]=x;
        v[nxt[mx]]=y;
    }
    LL find(LL x){
        LL mx=x%HASH_MOD;
        while(x!=h[mx]&&nxt[mx]!=-1)mx=nxt[mx];
        if(x!=h[mx])return -1;
        return v[mx];
    }
};

map hash;

LL power(LL x,LL y,LL Mod){
    x%=Mod;
    LL ans=1;
    while(y){
        if(y&1)ans=ans*x%Mod;
        x=x*x%Mod;
        y>>=1;
    }
    return ans;
}

LL ex_gcd(LL x,LL y,LL &a,LL &b){
    if(y==0){a=1;b=0;return x;}
    LL fa,fb;
    LL c=ex_gcd(y,x%y,fa,fb);
    a=fb;
    b=fa-fb*(x/y);
    return c;
}

int main(){

    while(scanf("%lld%lld%lld",&p,&b,&n)!=EOF){

        b%=p;n%=p;

        hash.clear();
        LL MAXN=ceil(sqrt((double)p));
        bool flag=false;
        for(LL i=0;i<MAXN;i++){
            LL tmp=power(b,i,p);
            if(tmp==n){printf("%lld\n",i);flag=true;break;}
            hash.insert(tmp,i);
        }
        if(flag)continue;

        LL QMM=power(b,MAXN,p);
        if(QMM==n){printf("%lld\n",MAXN);goto nxt;}
        ex_gcd(QMM,p,fx,fy);
        fx=(fx*n%p+p)%p;
        if((ans=hash.find(fx))!=-1){printf("%lld\n",ans+MAXN);goto nxt;}

        for(LL i=2;i<=MAXN;i++){
            LL tmp=power(QMM,i,p);
            ex_gcd(tmp,p,fx,fy);
            fx=(fx*n%p+p)%p;
            if((ans=hash.find(fx))!=-1){printf("%lld\n",ans+MAXN*i);goto nxt;}
        }

        printf("no solution\n");

        nxt:;
    }

    return 0;
}