[Luogu3846] [TJOI2007] 可爱的质数 [BSGS]

最新推荐文章于 2024-03-02 20:20:16 发布

原创最新推荐文章于 2024-03-02 20:20:16 发布 · 147 阅读

0 ·

CC 4.0 BY-SA版权

本文深入解析了BSGS算法，一种高效解决离散对数问题的方法。通过扩展欧拉定理，文章阐述了如何在特定条件下寻找最小正整数解。算法的实现包括哈希表的应用，以及快速幂运算，确保了在大模数下的高效运行。

[ $\frak{Link}$ ]

欧拉定理 $a^{\phi(p)}\equiv1\pmod{p}$

扩展欧拉定理 $g^r\equiv g^{[r\mod{\phi(p})]+\phi(p)}\pmod{p}$
特殊地、当 $(r, p) = 1$ 时 ${g^r\equiv g^{r\mod{\phi(p)}}\pmod{p}}$

BSGS：求 $g^r\equiv a\pmod{p}$ 的最小正整数解 $r_x$ 。

由扩展欧拉定理 $0<r_{x}<p$ 。
设 $r = i m - j$ 得到 $g^{im}\equiv ag^{j}\pmod{p}$ 并且有 $0 < i m - j < p$ 。
$j\in[0,m)$ ，对应的 $i$ 可能的取值为 $[1,\lceil\frac{p}{m}\rceil]$ 。

所以枚举 $j\in[0,m)$ ，存下 $ag^j\pmod{p}$ 对应最大的 $j$ 。
然后枚举 $i\in[1,m]$ ，计算 $g^{im}\pmod{p}$ 查表得到 $i m - j$ 。
复杂度 $O(\max(m,\lceil\frac{p}{m}\rceil))$ 所以我们取 $m=\sqrt{p}$ 。
查表用 hash 会快，用 map 虽然牺牲一个 log 但是（也许）稳一点。
或者用 stl::hash_map？

打完 hash 我的感觉就是尽量用 map 吧（
不过写写 hash 也不是很难（？）模数也比较宽松
注意题目的条件，同时也是不加特判 BSGS 的限制。就是那堆 $2\le\cdots$

#include<cstdio>
#include<cmath>
#include<iostream>
#include<algorithm>
using namespace std;

#define PIL pair<int, long long>

const int HASHSIZE = 1 << 18;
const long long HASHMOD = 1ll * (HASHSIZE - 1);


long long p, g, a, m;
struct Node
{
	int Index;
	long long Value;
	int Next;
	
	Node(int a = -1, long long b = -1, int c = -1)
	{
		Index = a;
		Value = b;
		Next = c;
	}
	
	bool IsEmpty()
	{
		return (Index==-1)&&(Value==-1)&&(Next==-1);
	}
	
} HashList[HASHSIZE+5];


int GetHashValue(long long OriginalValue)
{
	return (int) (OriginalValue & HASHMOD);
}

long long QuickPow(long long Base, long long Index, long long Mod)
{
	long long Result = 1;
	
	Base %= Mod;
	
	while (Index)
	{
		if (Index & 1)
		{
			Result *= Base;
			Result %= Mod;
		}
		Base *= Base;
		Base %= Mod;
		Index >>= 1;
	}
	return Result;
}

void HashInsert(long long Value, long long Index)
{
	int HashValue = GetHashValue(Value);
	int HashPos = HashValue;
	while (HashList[HashPos].Next != -1) HashPos = HashList[HashPos].Next;
	if (!HashList[HashPos].IsEmpty())
	{
		while(!HashList[HashList[HashPos].Next].IsEmpty()) ++HashList[HashPos].Next;
		HashPos = HashList[HashPos].Next;
	}
	HashList[HashPos] = Node(Index, Value);
}

long long HashQuery(long long Value)
{
	int HashPos = GetHashValue(Value);
	while (HashList[HashPos].Next != -1 && HashList[HashPos].Value != Value) HashPos = HashList[HashPos].Next;
	if (HashList[HashPos].IsEmpty() || HashList[HashPos].Value!=Value) return -1;
	return HashList[HashPos].Index;
}

int main()
{
	scanf("%lld%lld%lld", &p, &g, &a);
	
	m = (long long)ceil(sqrt(1.0*p));
	for (long long j = 0, t = a; j < m; ++j, t *= g, t %= p) HashInsert(t, j);
	for (long long tem, i = 1, t = QuickPow(g, m, p), s = t; i <= m; ++i, s *= t, s %= p)
	{
		tem = HashQuery(s);
		if (tem != -1)
		{
			printf("%lld", i * m - tem);
			return 0;
		}
	}
	
	printf("no solution");
	return 0;
}