BSGS算法

主要的思路就是分块，折半搜索。

P为质数时，POJ2417：

#include<cstdio>
#include<cstring>
#include<cctype>
#include<cmath>
#include<algorithm>
using namespace std;

int P,B,N;
struct Hashmap
{
	#define Hash 300007
	#define Maxsiz 100005
	int info[Hash],Prev[Maxsiz],key[Maxsiz],val[Maxsiz],siz;
	int del[Maxsiz],cnt;
	
	void clear(){ for(;cnt;info[del[--cnt]]=0);siz=0; }
	void insert(int k,int v)
	{
		int tmp;
		for(int i=info[tmp=k%Hash];i;i=Prev[i])
			if(key[i]==k)
			{
				val[i]=min(val[i],v);
				return;
			}
		!(Prev[++siz]=info[tmp]) && (del[cnt++]=tmp);
		key[info[tmp]=siz]=k;
		val[siz]=v;
	}
	int operator[](int k)
	{
		for(int i=info[k%Hash];i;i=Prev[i])
			if(key[i]==k)
				return val[i];
		return -1;
	}
}M;

inline int Pow(int base,int k,int P)
{
	int ret=1;
	for(;k;k>>=1,base=1ll*base*base%P) if(k&1) ret=1ll * ret *base % P;
	return ret;
}

int main()
{
	while(~scanf("%d%d%d",&P,&B,&N))
	{
		M.clear();
		int S=(int)(ceil(sqrt(1.0*P))),invb=1,bm=1,inv=Pow(B,P-2,P);
		for(int i=0;i<S;i++,invb=1ll * invb * inv % P,bm=1ll * bm * B % P) 
			M.insert(1ll * invb * N % P,i);
			
		bool ERROR=1;
		for(int i=0,sum=1;i<S;i++,sum=1ll * sum * bm % P) 
			if(M[sum]!=-1)
			{
				printf("%d\n",i*S+M[sum]);
				ERROR=0;
				break;
			}
		if(ERROR) printf("no solution\n");
	}
}

P为合数时：

#include<cstdio>
#include<cstring>
#include<cctype>
#include<algorithm>
#include<cmath>
using namespace std;

int A,P,B;
struct Hashmap
{
	#define Hash 300007
	#define Maxsiz 100005
	int info[Hash],Prev[Maxsiz],key[Maxsiz],val[Maxsiz],siz;
	int del[Maxsiz],cnt_del;
	
	void clear(){ for(siz=0;cnt_del;info[del[--cnt_del]]=0); }
	void insert(int k,int v)
	{
		int tmp=k%Hash;
		for(int i=info[tmp];i;i=Prev[i])
			if(key[i]==k)
				return void(val[i]=min(val[i],v));
		!(Prev[++siz]=info[tmp]) && (del[cnt_del++]=tmp);
		key[info[tmp]=siz]=k,val[siz]=v;
	}
	int operator[](int k)
	{
		for(int i=info[k%Hash];i;i=Prev[i])
			if(key[i]==k)
				return val[i];
		return -1;
	}
}M;

inline int Pow(int base,int k,int P)
{
	int ret=1;
	for(;k;k>>=1,base=1ll * base * base % P) 
		if(k&1) 
			ret=1ll * ret * base % P;
	return ret;
}

int gcd(int a,int b){ return !b?a:gcd(b,a%b); }
void exgcd(int a,int b,int &x,int &y)
{
	if(!b) x=1,y=0;
	else exgcd(b,a%b,y,x),y-=a/b*x;
}
int getinv(int a,int b){ int x,y; exgcd(a,b,x,y); return x;}

int Solve(int A,int P,int B)
{
	M.clear();
	int GCD,usd=0,had=1,c=P,b=B,S;
	while((GCD=gcd(A,P))>1)
	{
		if(B%GCD) return -1;
		B/=GCD,P/=GCD,usd++,had=1ll * had * (A/GCD) % P;
	}
	S=(int)(ceil(sqrt(1.0 * P)))+1;
	for(int i=0,sum=1;i<usd;i++,sum=1ll * sum * A % c)
		if(sum==b) return i;
	for(int i=0,inv=(getinv(A,P)%P+P)%P,sum=B % P;i<S;i++,sum=1ll * sum * inv % P) 
		M.insert(sum,i);
	for(int i=0,sum=had%P,bm=Pow(A,S,P);i<S;i++,sum=1ll * sum * bm % P)
		if(M[sum]!=-1)
			return i*S+M[sum]+usd;
	return -1;
}

int main()
{
	int tmp;
	while(~scanf("%d%d%d",&A,&P,&B) && (A || P || B))
	{
		if((tmp = Solve(A%P,P,B%P)) == -1) puts("No Solution");
		else printf("%d\n",tmp);
	}
}

UPD：

大佬博客

在同余式两边虽然可以同时乘上一个数使得同余式仍然成立，但是这会导致解的数量增多，只有在乘的数与模数$\gcd$为1时才是等价变换。

http://www.360doc.com/content/18/0817/12/11564502_778968047.shtml

换句话说，只要底数有逆，就算是矩阵也可以直接BSGS而不需EX。

短小精悍版：

#include<bits/stdc++.h>
using namespace std;

int gcd(int a,int b){ return !b?a:gcd(b,a%b); } 
map<int,int>mp;
int solve(int a,int b,int p){
	a%=p,b%=p;
	int cnt = 0 , at = 1;
	for(int g=gcd(a,p);g>1;g=gcd(a,p)){
		if(b%g) return -1;
		cnt++;
		at=1ll*at*(a/g)%p;
		p/=g,b/=g;
	}
	int M = sqrt(p);
	int base=1;
	mp.clear();
	for(int i=0;i<M;i++,base=1ll*base*a%p)
		mp[1ll*base*b%p]=i; // we need the greatest i
	mp[1ll*base*b%p]=M;	// to cover the situation where the answer is 0
	for(int i=1;i<=M+1;i++){
		at = 1ll * at * base % p;
		if(mp.count(at))
			return i*M-mp[at]+cnt;
	}
	return -1;
}

int main(){
	int a,b,p;
	for(;~scanf("%d%d%d",&p,&a,&b);){
		int tmp = solve(a,b,p);
		if(tmp!=-1) printf("%d\n",tmp);
		else puts("no solution");
	}
}

mod质数意义下的K次剩余可以用exgcd+BSGS算。

主要思想就是两边同时取然后变成线性模方程直接上