Baby Step Giant Step 初步

最新推荐文章于 2024-06-19 08:00:00 发布

.SAI.

最新推荐文章于 2024-06-19 08:00:00 发布

阅读量114

点赞数

分类专栏：数论初步文章标签：算法 c++ ssl 数论

本文链接：https://blog.csdn.net/SAI_2021/article/details/125089899

版权

数论初步专栏收录该内容

8 篇文章 1 订阅

订阅专栏

引入

对于 $a,b,m\in\N，\gcd(a,m)=1$ 求解指数同余方程
$a^x\equiv b\pmod m$
的最小正数解。

BSGS (Baby step Giant step)

我们考虑余数是存在循环节的，也就是说某个数 $\bmod m$ 只有 $[0, m - 1]$ 个取值，于是我们尝试寻找 $a^x\bmod m$ 的循环节。
由欧拉定理可知 $a^{\varphi(m)}\equiv 1\pmod m$ ,因此有 $a^x\bmod m$ 的取值只有 $\varphi(m)$ 种，一旦 $x$ 大于 $\varphi(m)$ ，那么就会与之前的值重复，答案不是最优。这个想法也可以从欧拉定理的推论 $a^{b\bmod \varphi(m)}\equiv a^b\pmod m$ 得到，万变不离其宗。
于是有暴力思想，枚举 $[1,\varphi(m)]$ 的数作为 $x$ 的值，暴力判断是否满足方程。但是当 $m\ge 10^8$ 且为质数时， $\varphi(m)=m-1\ge 10^8$ ，该思路任然会超时。

于是我们就引入了“优化暴力”的 $B a b y s t e p G i a n t s t e p$ 算法，简称 $\mathbf{BSGS}$

考虑 $\gcd(a,m)=1$ ，因此我们可以对同余式进行整除运算（裴蜀定理可得吧，这里就不赘述了），即可以将 $x$ 表示为 $x=i\cdot t-j$ ，我们设 $t=\left\lceil\sqrt m\right\rceil$ 。
于是原方程变为
$a^{i\cdot t-j}\equiv b\pmod m\\ ~\\ \dfrac{a^{i\cdot t}}{a^j}\equiv b\pmod m\\ ~\\ a^{i\cdot t}\equiv b\cdot a^j\pmod m\\ ~\\ (a^t)^i\equiv b\cdot a^j\pmod m$

此时我们将原方程的 $x$ 分块来枚举，就可以均摊复杂度。
我们先枚举方程右边的 $j$ ,然后将 $j$ 取值，按照右边的余数对应存进一个 $h a s h$ 表里（说是这么说，但是我还是常用 $m a p$ 或 $u n o r d e r e d$ _ $m a p$ ），然后同理枚举方程左边的 $i$ ,查找是否有 $j$ 与 $i$ 方程两边余数匹配，即同余（这时候就用上先前的 $h a s h$ 表来查找），若匹配则直接得到答案 $x=i\cdot t-j$ 。

当 $i, j$ 取 $[1, t]$ 的值时，我们可以得到所有 $x\in[1,m-1]$ 的解，显然符合先前所得的答案范围 $[1,\varphi(m)]$ 。
但是这个算法是可以通过的，时间为 $\Theta(\sqrt m)$ 。
此算法与原先纯暴力最大的不同，就是我们将枚举进行了分块，将枚举范围分为了两部分，各为 $\sqrt m$ ，这种思想有点像折半搜索（砍两瓣，分开搜索），将暴力复杂度拆开了。

这就是 $\mathbf{BSGS}$ ,也就是一种优化了的暴力算法。

回忆一下思路，其实也很清晰，就是把答案分成两部分分别枚举然后对应查找，于是代码也很好实现。

int BSGS(int a,int b,long long p)
{
   map<int,int> vis;
   int t=sqrt(p)+1,mi=1;
   for(int i=1;i<=t;i++)
   {
       if(i!=0) mi=(__int128)(mi*a)%p;
       vis[(__int128)(b*mi)%p]=i;
   }
   a=mi;
   if(!a) return (b%p==0)?1:-1; //特判，若a能被模数整除，那么当且仅当b也能被模数整除的情况下存在最小正数解 1，否则无解
   mi=1;
   for(int i=1;i<=t;i++)
   {
     map<int,int>::iterator it;
     if(i!=0) mi=(__int128)(mi*a)%p;  //暴力求余
     it=vis.find(mi);  //查找对应
     if(it!=vis.end())
       if((__int128)i*t-(it->second)>=0) return (__int128)(i*t-(it->second));
   }
   return -1;
}