BSGS专练

文章目录

• 数论之神(待理解）
• 扩展BSGS
• P3846 [TJOI2007] 可爱的质数/【模板】BSGS
• #4128. Matrix
• #3122. [Sdoi2013]随机数生成器
• 【BZOJ5104】Fib数列（BSGS，二次剩余）

数论之神(待理解）

扩展BSGS

1. 首先一般BSGS处理的是a,p互质的情况，因为在这种情况下适用欧拉定理，所以解的范围比较小可以直接分块，但是虽然此时仍然有扩展欧拉定理，但是它不优。
2. 我们可以利用裴蜀定理的性质将其转换为a,p互质的情况，那么就是每次提取(a,p)，然后有解的必要条件就是(a,p)|b或b=1,x=0，所以发现三个数都是(a,p)的倍数，所以我们可以同时除掉，然后就变为了一个规模更小的问题，迭代不超过$O(logn)$次必然就有(a,p)=1,此时我们就可以直接使用BSGS处理了
3. 注意一些b=1特判,还有迭代过程中出现B=C也需要特判此时解就是k，因为之后BSGS的结果必然大于k，过程中(a,p)不整除b的时候直接输出no solution

#include<bits/stdc++.h>
#define LL long long
#define I inline int
#define V inline void
#define FOR(i,a,b) for(register int i=a,end##i=b;i<=end##i;++i)
#define REP(i,a,b) for(register int i=a,end##i=b;i>=end##i;--i)
#define go(i,a) for(register i=hed[a];i;i=e[i].pre)
using namespace std;
inline int read()
{
	char x='\0';
	int fh=1,sum=0;
	for(x=getchar();x<'0'||x>'9';x=getchar())if(x=='-')fh=-1;
	for(;x>='0'&&x<='9';x=getchar())sum=sum*10+x-'0';
	return fh*sum;
}
I gcd(int a,int b){return (b==0)?a:gcd(b,a%b);}
I ksm(int a,int b,int mod)
{
	int sum=1;
	while(b)
	{
		if(b&1)sum=1LL*sum*a%mod;
		b>>=1,a=1LL*a*a%mod;
	}
	return sum;
}
map<int,int>mp;
I exBSGS(int a,int b,int p)
{
	int d=gcd(a,p),c=1,k=0;
	if(b==1)return 0;
	while(d!=1)
	{
		if(b%d!=0)return -1;
		p/=d,b/=d,c=1LL*c*(a/d)%p,k++;
		d=gcd(a,p);
		if(b==c)return k;
	}
//	cout<<"k a b p "<<k<<' '<<a<<' '<<b<<' '<<p<<endl;//
	int m=ceil(sqrt(p));
	mp.clear();
	for(int i=0,t=b;i<m;i++,t=1LL*t*a%p)mp[t]=i;
	for(int i=1,t=ksm(a,m,p),s=1LL*c*t%p;i<=m;i++,s=1LL*s*t%p)
		if(mp.find(s)!=mp.end())return m*i-mp[s]+k;
	return -1;
}
int main()
{
	int A=0,B=0,P=0;
	while(scanf("%d%d%d",&A,&P,&B)!=EOF)
	{
		if(!A&&!B&&!P)return 0;
		int ans=exBSGS(A%P,B%P,P);
		if(ans<0)printf("No Solution\n");
		else printf("%d\n",ans);
	}
	return 0;
}
/*
5 58 33
2 4 3
0 0 0
*/

P3846 [TJOI2007] 可爱的质数/【模板】BSGS

主要是注意几个细节：

1. 首先是ceil(sqrt(mod))
2. 然后就是b%=mod,这一步很关键
3. map清空
4. 枚举的时候要在map里存b*a^i的值
5. 特判a=0的情况，b=0则return 1否则return -1
6. 最后没有找到解要return -1

#4128. Matrix

矩阵BSGS，现在要求的就是对一个矩阵求对数，那么我们的做法还是BSGS，然后分块处理即可，只不过有一些代码细节需要注意。

1. 首先就是map的比较运算符需要自己定义，并且还要满足我们的要求，必须满足偏序关系，实际上我们可以把矩阵哈希一下也是可以的。但是这里有一个细节就是两个矩阵相等时必须要return false只有这样才是合法的运算。
2. 重载中括号的时候不能加friend
3. 出现expected initialzer…的时候就是忘记加分号了。

#3122. [Sdoi2013]随机数生成器

这道题已知$x_i=a{x}_{i-1}+b$给出$x_1,a,b,x_n$求解一个最小的n

首先这是一个线性变换的形式，所以我们可以想到利用矩阵求解，所以就是一个类似于4128的问题了。

另外这道题还有一个更简洁的方法，就是利用数列知识，将其化为等比数列，这样直接BSGS即可。

【BZOJ5104】Fib数列（BSGS，二次剩余）

对于一个给出fn求解n的问题，首先我们利用其通项公式，可以表示成一个$\frac{1}{\sqrt{5}}(A^n-B^n)$其中$A=\frac{1+\sqrt{5}}{2},B=\frac{1-\sqrt{5}}{2}$然后可以发现这个东西实际上$A=-\frac{1}{B}$所以改写这个式子$\frac{1}{\sqrt{5}}(\frac{1}{(-B{)}^n}-B^n)$然后根据n的奇偶性进行分类讨论即可，然后可以得到一个一元二次方程，得出两个解检验即可，所以总共可能会有4个解，我们选择最小的即可。

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<vector>
#include<map>
using namespace std;
#define MOD 1000000009
int fpow(int a,int b){int s=1;while(b){if(b&1)s=1ll*s*a%MOD;a=1ll*a*a%MOD;b>>=1;}return s;}
namespace SQRT
{
	bool check(int n){return fpow(n,(MOD-1)>>1)==1;}
	int w;struct Num{int a,b;};
	Num operator*(Num a,Num b){return (Num){(1ll*a.a*b.a+1ll*a.b*b.b%MOD*w)%MOD,(1ll*a.a*b.b+1ll*a.b*b.a)%MOD};}
	Num fpow(Num a,int b){Num s=(Num){1,0};while(b){if(b&1)s=s*a;a=a*a;b>>=1;}return s;}
	int Sqrt(int n)
	{
		if(!check(n))return -1;
		int a;do a=rand()%MOD;while(check((1ll*a*a+MOD-n)%MOD));
		w=(1ll*a*a-n+MOD)%MOD;
		return fpow((Num){a,1},(MOD+1)>>1).a;
	}
}
namespace BSGS
{
	map<int,int> M;
	const int m=sqrt(MOD);
	int BSGS(int x,int y)
	{
		M.clear();
		for(int i=0,t=1;i<m;++i,t=1ll*t*x%MOD)M[1ll*y*t%MOD]=i;
		for(int i=1,p=fpow(x,m),t=p;i<=m;++i,t=1ll*t*p%MOD)
			if(M.find(t)!=M.end())
				return i*m-M[t];
		return 2e9;
	}
}
int n,ans=2e9;
int main()
{
	int sqrt5=SQRT::Sqrt(5);
	scanf("%d",&n);
	int A=MOD-1,B=(MOD-1ll*sqrt5*n%MOD)%MOD;
	int d1=(1ll*B*B%MOD+MOD-4ll*A%MOD)%MOD;
	int d2=(1ll*B*B%MOD+4ll*A%MOD)%MOD;
	if(SQRT::check(d1))
	{
		int vd=SQRT::Sqrt(d1);
		int x1=1ll*(0ll+MOD-B+vd)%MOD*fpow(A+A,MOD-2)%MOD;
		int x2=1ll*(0ll+MOD-B+MOD-vd)%MOD*fpow(A+A,MOD-2)%MOD;
		int beta=1ll*(1+MOD-sqrt5)*fpow(2,MOD-2)%MOD;
		int n1=BSGS::BSGS(beta,x1);
		int n2=BSGS::BSGS(beta,x2);
		if(!(n1&1))ans=min(ans,n1);
		if(!(n2&1))ans=min(ans,n2);
	}
	if(SQRT::check(d2))
	{
		int vd=SQRT::Sqrt(d2);
		int x1=1ll*(0ll+MOD-B+vd)%MOD*fpow(A+A,MOD-2)%MOD;
		int x2=1ll*(0ll+MOD-B+MOD-vd)%MOD*fpow(A+A,MOD-2)%MOD;
		int beta=1ll*(1+MOD-sqrt5)*fpow(2,MOD-2)%MOD;
		int n1=BSGS::BSGS(beta,x1);
		int n2=BSGS::BSGS(beta,x2);
		if(n1&1)ans=min(ans,n1);
		if(n2&1)ans=min(ans,n2);
	}
	printf("%d\n",ans<MOD?ans:-1);
	return 0;
}