BSGS 大步小步算法

BSGS 大步小步算法

\(Baby~Step, Giant~Step\)，大步小步算法（轻量级算法，求解高次同余方程）。

思路

先上例题：给定整数 \(a,b,p\)，其中 \(\mathbf{a,p}\) 互质，求一个非负整数 \(x\)，使得 \(a^x\equiv b\pmod p\)

朴素算法概述：

考虑一个暴力算法，在 \(\bmod~p\) 的意义下，\(a^x\) 显然有一个长度为 \(\varphi(p)\) 的循环节，所以只需要考虑 \(x\le \varphi(p)\) 的情况即可。

暴力枚举 x 求解，时间复杂度 \(O(\varphi(p))\)，最坏 \(O(p-1)\)

而 \(BSGS\) 则运用类似于 拆半搜索 的思想，将 x 表示成 \(i\times t - j\) 的形式。

于是原式 \(\to a^{i\times t}\equiv b\times a^{j}\pmod p\)

固定 t 的值，预处理出右式所有可能的取值。

枚举计算左式可能的值，当枚举到某个在右边已经出现过的值时，此时 \(i\times t - j\) 就是我们要求的 x。

t 的取值：

\(j\) 的取值为 \(\varphi(p) \bmod t\) 共计 \(t-1\) 个，\(i\) 的取值有 \(\lceil\frac{\varphi(p)}{t}\rceil\) 个。

\(t\) 取 \(\sqrt{\varphi(p)}\) 时有最优复杂度（最平均），但为避免计算 \(\varphi(p)\)，近似取 \(t=\sqrt{p}\) 即可。

时间复杂度 \(O(\sqrt{p})\)

exBSGS

求解 \(a^x\equiv b\pmod p\) 需要满足条件 \(a\perp p\) ，而 \(exBSGS\) （扩展 \(BSGS\)）主要解决 \(a\not\perp p\) 的情况。

设 \(d=gcd(a,p)\)，若我们把同余式两边同时除以 \(d\) ，如此可以构造互质。

因为 \(d\mid a^x\bmod p\)，所以 \(b\neq 1\) 时，必然有 \(d\mid b\) ，否则原同余式无解。

于是原式 \(\to a^{x-1}\frac{a}{d}\equiv \frac{b}{d}\pmod {\frac{p}{d}}\)

运用 \(exgcd\) ，原式 \(\to a^{x-1}\equiv \frac{b}{d}(\frac{a}{d})^{-1}\pmod {\frac{p}{d}}\)

但是 \(a\) 不一定与 \(\frac{p}{d}\) 互质，于是递归进入子问题求解，直到 \(a\) 与模数互质（\(d=1\)）为止。

完美解决，撒花。

练习题目

可爱的质数/[模板]BSGS

模板。

class BSGS{
public:
    LL mod, a, b, t, power;
    std::unordered_map<LL, int> hash;
    BSGS(LL _a, LL _b, LL _mod){a = _a, b = _b, mod = _mod, t = std::ceil(std::sqrt(mod)) + 1, power = 1;};
    int work()
    {
        for (int j = 0; j < t; j++)
            hash[b * power % mod] = j, power = power * a % mod;
        LL res = power;
        for (int i = 1; i <= t; i++)
        {
            auto iter = hash.find(power);
            int val = iter != hash.end() ? iter->second : mod;
            if (val != mod)
                return i * t - val;
            power = power * res % mod;
        }
        return -1;
    }
};
int main()
{
    BSGS bsgs(/*a, b, p*/);
    std::cout << bsgs.work();
    return 0;
}

多少个1?

再送一道 \(bsgs\) 模板。

[ 模板]扩展 BSGS/exBSGS

\(exbsgs\) 的模板题。

#include <bits/stdc++.h>
using LL = long long;
class BSGS{
public:
    LL mod, a, b, t, power;
    std::unordered_map<LL, int> hash;
    BSGS(LL _a, LL _b, int _mod){a = _a, b = _b, mod = _mod, t = std::ceil(std::sqrt(mod)), power = 1;};
    int work()
    {
        hash.clear();
        for (int j = 0; j < t; j++)
            hash[b * power % mod] = j, power = power * a % mod;
        LL res = power;
        for (int i = 1; i <= t; i++)
        {
            auto iter = hash.find(power);
            int val = iter != hash.end() ? iter->second : mod;
            if (val != mod)
                return i * t - val;
            power = power * res % mod;
        }
        return -10000;
    }
}bsgs(0, 0, 0);
void exgcd(LL a, LL b, LL &x, LL &y)
{
    if (b == 0)
        return void(x = 1), void(y = 0);
    exgcd(b, a % b, x, y);
    LL z = x;
    x = y, y = z - y * (a / b);
}
LL inv(LL a, int mod)
{
    LL x, y; exgcd(a, mod, x, y);
    return (x % mod + mod) % mod;
}

LL dfs(LL a, LL b, LL mod)
{
    if (a == b) return 1;
    LL d = std::__gcd(a, mod);
    if (d == 1) return void(bsgs = BSGS(a, b, mod)), bsgs.work();
    if (b % d) return -10000;
    mod /= d;
    return dfs(a % mod, (b / d) * inv(a / d, mod) % mod, mod) + 1;
}

int main()
{
    LL a, b;
    int mod;
    auto work = [](LL a, LL b, int mod)->LL{
        if (b == 1 || mod == 1) return 0;
        if (!a) return b ? -1 : 1;
        if (b == 1) return 0;
        return dfs(a, b, mod);
    };
    while (1)
    {
        scanf("%lld %d %lld", &a, &mod, &b);
        if (!mod) break;
        a %= mod, b %= mod;
        LL ans = work(a, b, mod);
        if (ans >= 0) printf("%lld\n", ans);
        else puts("No Solution");
    }
    return 0;
}