baby_step giant_step hdu 2815 mod tree pku 3243 Clever Y

最新推荐文章于 2022-03-03 21:34:11 发布
最新推荐文章于 2022-03-03 21:34:11 发布
阅读量164 收藏
点赞数
原文链接：http://www.cnblogs.com/xiaoxian1369/archive/2011/08/05/2128776.html
版权

原创帖！转载请注明作者 AekdyCoin !

【普通Baby Step Giant Step】

【问题模型】
求解
A^x = B (mod C) 中 0 <= x < C 的解,C 为素数

【思路】
我们可以做一个等价
x = i * m + j  ( 0 <= i < m, 0 <=j < m) m = Ceil ( sqrt( C) )
而这么分解的目的无非是为了转化为:
(A^i)^m * A^j = B ( mod C)

之后做少许暴力的工作就可以解决问题：
(1) for i = 0 -> m, 插入Hash (i, A^i mod C)
(2) 枚举 i ,对于每一个枚举到的i,令  AA = (A^m)^i mod C
我们有
AA * A^j = B (mod C)
显然AA,B,C均已知，而由于C为素数,那么(AA,C)无条件为1
于是对于这个模方程解的个数唯一(可以利用扩展欧几里得或 欧拉定理来求解)
那么对于得到的唯一解X,在Hash表中寻找,如果找到，则返回 i * m + j
注意:由于i从小到大的枚举,而Hash表中存在的j必然是对于某个剩余系内的元素X 是最小的(就是指标)
所以显然此时就可以得到最小解

如果需要得到 x > 0的解，那么只需要在上面的步骤中判断 当 i * m + j > 0 的时候才返回


到目前为止，以上的算法都不存在争议,大家实现的代码均相差不大。可见当C为素数的时候，此类离散对数的问题可以变得十分容易实现。


【扩展Baby Step Giant Step】

【问题模型】
求解
A^x = B (mod C) 中 0 <= x < C 的解,C 无限制(当然大小有限制……)

【写在前面】
这个问题比较麻烦，目前网络上流传许多版本的做法，不过大部分已近被证明是完全错误的！

这里就不再累述这些做法，下面是我的做法(有问题欢迎提出)

下面先给出算法框架，稍后给出详细证明:

(0) for i = 0 -> 50 if(A^i mod C == B) return i    O(50)
(1)  d<- 0                D<- 1 mod C
while((tmp=gcd(A,C))!=1)
{
if(B%tmp)return -1; // 无解!
++d;
C/=tmp;
B/=tmp;
D=D*A/tmp%C;
}
(2) m = Ceil ( sqrt(C) ) //Ceil是必要的     O(1)
(3) for i = 0 -> m 插入Hash表(i, A^i mod C)  O( m)
(4) K=pow_mod(A,m,C)
for i = 0 -> m
解 D * X = B (mod C) 的唯一解 (如果存在解，必然唯一!)
之后Hash表中查询,若查到(假设是 j)，则 return i * m + j + d
否则
D=D*K%C,继续循环
(5) 无条件返回 -1 ;//无解!


下面是证明:
推论1:
A^x = B(mod C)
等价为
A^a  * A^b  = B ( mod C)   (a+b) == x       a,b >= 0

证明:
A^x = K * C + B (模的定义)
A^a * A^b = K*C + B( a,b >=0, a + b == x)
所以有
A^a * A^b = B(mod C)

推论 2:

令 AA * A^b = B(mod C)

那么解存在的必要条件为:  可以得到至少一个可行解 A^b = X (mod C)

使上式成立

推论3

AA * A^b = B(mod C)

中解的个数为 (AA,C)

由推论3 不难想到对原始Baby Step Giant Step的改进

For I = 0 -> m

 For any solution that AA * X = B (mod C)

If find X

  Return I * m + j

而根据推论3,以上算法的复杂度实际在 (AA,C)很大的时候会退化到几乎O(C)

归结原因，是因为(AA,C)过大，而就是(A,C)过大
于是我们需要找到一中做法，可以将(A,C)减少，并不影响解

下面介绍一种“消因子”的做法

一开始D = 1 mod C
进行若干论的消因子,对于每次消因子
令 G = (A,C[i])  // C[i]表示经过i轮消因子以后的C的值
如果不存在 G | B[i]  //B[i]表示经过i轮消因子以后的B的值
直接返回无解
否则
B[i+1] = B[i] / G
C[i+1] = C[i] / G
D = D * A / G

具体实现只需要用若干变量,细节参考代码

假设我们消了a'轮(假设最后得到的B,C分别为B',C')
那么有
D * A^b = B' (mod C')

于是可以得到算法

for i = 0 -> m
解 ( D* (A^m) ^i ) * X = B'(mod C')
由于 ( D* (A^m) ^i , C') = 1 (想想为什么？)
于是我们可以得到唯一解
之后的做法就是对于这个唯一解在Hash中查找

这样我们可以得到b的值,那么最小解就是a' + b !!

现在问题大约已近解决了，可是细心看来，其实还是有BUG的，那就是
对于
A^x = B(mod C)
如果x的最小解< a',那么会出错
而考虑到每次消因子最小消 2
故a'最大值为log(C)
于是我们可以暴力枚举0->log(C)的解，若得到了一个解，直接返回
否则必然有 解x > log(C)

PS.以上算法基于Hash 表,如果使用map等平衡树维护，那么复杂度会更大

hdu 2815

#include<stdio.h>
#include<math.h>
#include<stdlib.h>
#define LL long long
#define nmax 5000005
typedef struct node {
	int num, ii;
} node;
node Node[nmax];
int x, y;
int cmp(const void *n, const void *m) {
	node *a = (node *) n;
	node *b = (node *) m;
	if (a->num == b->num) {
		if (a->ii > b->ii) {
			return 1;
		}
		return -1;
	}
	if (a->num > b->num) {
		return 1;
	}
	return -1;
}
int gcd(int a, int b) {
	int te;
	if (a < b) {
		te = a, a = b, b = te;
	}
	if (b == 0) {
		return a;
	}
	return gcd(b, a % b);
}
int ext_gcd(int a, int b) {
	if (b == 0) {
		x = 1, y = 0;
		return a;
	}
	int d = ext_gcd(b, a % b);
	int tx = x;
	x = y, y = tx - a / b * y;
	return d;
}
int inval(int a, int b, int n) {
	int e;
	ext_gcd(a, n);
	e = (LL) x * b % n;
	return e < 0 ? e + n : e;
}
int modular_exp(int a, int b, int c) {
	LL ret = 1 % c, te = a % c;
	while (b) {
		if (b & 1) {
			ret = ret * te % c;
		}
		te = te * te % c;
		b >>= 1;
	}
	return (int) ret;
}
int bsearchn(int x, int n) {
	int left, mid, right;
	left = 0, right = n + 1;
	while (left <= right) {
		mid = (left + right) / 2;
		if (Node[mid].num == x) {
			return Node[mid].ii;
		} else if (Node[mid].num > x) {
			right = mid - 1;
		} else {
			left = mid + 1;
		}
	}
	return -1;
}
int baby_step_giant_step(int a, int b, int c) {
	int i, j, d, tep, m, K, tem, k;
	LL D, buf;
	for (i = 0, buf = 1 % c, D = buf; i < 100; i++, buf = buf * a % c) {
		if (buf == b) {
			return i;
		}
	}
	d = 0;
	while ((tep = gcd(a, c)) != 1) {
		if (b % tep) {
			return -1;
		}
		++d;
		c /= tep, b /= tep;
		D = D * a / tep % c;
	}
	m = (int) (ceil(sqrt((double) c)));
	for (i = 0, buf = 1 % c; i <= m; i++, buf = buf * a % c) {
		Node[i].num = (int) buf;
		Node[i].ii = i;
	}
	qsort(Node, m + 1, sizeof(Node[0]), cmp);
	for (i = 0, j = 0, k = -1; i <= m; i++) {
		if (k != Node[i].num) {
			Node[j++] = Node[i];
			k = Node[i].num;
		}
	}
	m = j;
	K = modular_exp(a, m, c);
	for (i = 0; i <= m; i++, D = D * K % c) {
		tem = inval((int) D, b, c);
		if (tem >= 0) {
			if ((j = bsearchn(tem, m)) != -1) {
				return i * m + j + d;
			}
		}
	}
	return -1;
}
int main() {
#ifndef ONLINE_JUDGE
	freopen("t.txt", "r", stdin);
#endif
	int k, p, n, res;
	while (scanf("%d %d %d", &k, &p, &n) != EOF) {
		if (n >= p) {
			puts("Orz,I can’t find D!");
			continue;
		}
		res = baby_step_giant_step(k, n, p);
		if (res == -1) {
			puts("Orz,I can’t find D!");
			continue;
		}
		printf("%d\n", res);
	}
	return 0;
}

 

 最新版~！

/*
 a^x=b (mod c)
*/
#include<stdio.h>
#include<math.h>
#include<stdlib.h>
#define LL long long
#define nnum 100
#define nmax 31625
typedef struct num {
int ii, value;
} num;
num Num[nmax];
int x, y;
int cmp(const void *a, const void *b) {
    num n = *(num *) a;
    num m = *(num *) b;
return n.value - m.value;
}
int gcd(int a, int b) {
return b == 0 ? a : gcd(b, a % b);
}
void extend_gcd(int a, int b) {
int xx;
if (b == 0) {
        x = 1, y = 0;
return;
    }
    extend_gcd(b, a % b);
    xx = x;
    x = y, y = xx - a / b * y;
}
/*
 ax=b (mod n)
*/
int inval(int a, int b, int n) {
    LL res;
    extend_gcd(a, n);
    res = (LL) x;
    res = res * b;
    res = (res % n + n) % n;
return (int) res;
}
int bfindNum(int key, int n) {
int left, right, mid;
    left = 0, right = n;
while (left <= right) {
        mid = (left + right) >> 1;
if (Num[mid].value == key) {
return Num[mid].ii;
        } else if (Num[mid].value > key) {
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    }
return -1;
}
void baby_step_giant_step(int a, int b, int c) {
int i, j, te, d, cd, aa, ttemp;
    LL temp, tem;
if (b >= c) {
        puts("Orz,I can’t find D!");
return;
    }
for (i = 0, temp = 1 % c, tem = temp; i < nnum; i++, temp = temp * a % c) {
if (temp == b) {
            printf("%d\n", i);
return;
        }
    }
    cd = 0;
while ((d = gcd(a, c)) != 1) {
if (b % d) {
            puts("Orz,I can’t find D!");
return;
        }
        cd++;
        c /= d, b /= d;
        tem = tem * a / d % c;
    }
    te = (int) (sqrt(c * 1.0) + 0.5);
for (i = 0, temp = 1 % c; i <= te; i++, temp = temp * a % c) {
        Num[i].ii = i;
        Num[i].value = (int) temp;
    }
    aa = Num[te].value;
    qsort(Num, te + 1, sizeof(Num[0]), cmp);
for (i = 0; i <= te; i++, tem = tem * aa % c) {
        ttemp = inval(tem, b, c);
if (ttemp >= 0) {
            j = bfindNum(ttemp, te + 1);
if (j != -1) {
                printf("%d\n", i * te + j + cd);
return;
            }
        }
    }
    puts("Orz,I can’t find D!");
}
void solve(int a, int b, int c) {
    baby_step_giant_step(a, b, c);
}
int main() {
#ifndef ONLINE_JUDGE
    freopen("data.in", "r", stdin);
#endif
int k, p, n;
while (~scanf("%d %d %d", &k, &p, &n)) {
        solve(k, n, p);
    }
return 0;
}

 pku 3243

/*
 a^x=b (mod c)
*/
#include<stdio.h>
#include<math.h>
#include<stdlib.h>
#define LL long long
#define nnum 100
#define nmax 31625
typedef struct num {
int ii, value;
} num;
num Num[nmax];
int x, y;
int cmp(const void *a, const void *b) {
    num n = *(num *) a;
    num m = *(num *) b;
return n.value - m.value;
}
int gcd(int a, int b) {
return b == 0 ? a : gcd(b, a % b);
}
void extend_gcd(int a, int b) {
int xx;
if (b == 0) {
        x = 1, y = 0;
return;
    }
    extend_gcd(b, a % b);
    xx = x;
    x = y, y = xx - a / b * y;
}
/*
 ax=b (mod n)
*/
int inval(int a, int b, int n) {
    LL res;
    extend_gcd(a, n);
    res = (LL) x;
    res = res * b;
    res = (res % n + n) % n;
return (int) res;
}
int bfindNum(int key, int n) {
int left, right, mid;
    left = 0, right = n;
while (left <= right) {
        mid = (left + right) >> 1;
if (Num[mid].value == key) {
return Num[mid].ii;
        } else if (Num[mid].value > key) {
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    }
return -1;
}
void baby_step_giant_step(int a, int b, int c) {
int i, j, te, d, cd, aa, ttemp;
    LL temp, tem;
for (i = 0, temp = 1 % c, tem = temp; i < nnum; i++, temp = temp * a % c) {
if (temp == b) {
            printf("%d\n", i);
return;
        }
    }
    cd = 0;
while ((d = gcd(a, c)) != 1) {
if (b % d) {
            puts("No Solution");
return;
        }
        cd++;
        c /= d, b /= d;
        tem = tem * a / d % c;
    }
    te = (int) (sqrt(c * 1.0) + 0.5);
for (i = 0, temp = 1 % c; i <= te; i++, temp = temp * a % c) {
        Num[i].ii = i;
        Num[i].value = (int) temp;
    }
    aa = Num[te].value;
    qsort(Num, te + 1, sizeof(Num[0]), cmp);
for (i = 0; i <= te; i++, tem = tem * aa % c) {
        ttemp = inval(tem, b, c);
if (ttemp >= 0) {
            j = bfindNum(ttemp, te + 1);
if (j != -1) {
                printf("%d\n", i * te + j + cd);
return;
            }
        }
    }
    puts("No Solution");
}
void solve(int a, int b, int c) {
    baby_step_giant_step(a, b, c);
}
int main() {
#ifndef ONLINE_JUDGE
    freopen("data.in", "r", stdin);
#endif
int x, z, k;
while (~scanf("%d %d %d", &x, &z, &k) && (x || z || k)) {
        solve(x, k % z, z);
    }
return 0;
}

 

 

转载于:https://www.cnblogs.com/xiaoxian1369/archive/2011/08/05/2128776.html

weixin_33735077
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
we.zip_beltjl9_giant3b9_wavenumber spectrum_波数_波数谱
07-15
波数谱计算,可以计算分析各类数据的波数谱，从而分析其频率特征
离散对数及其拓展 大步小步算法 BSGS
稻云麦花的博客
09-11 609
离散对数及其拓展 离散对数是在群Zp∗Z_{p}^{*}Zp∗​而言的,其中ppp是素数。即在在群Zp∗Z_{p}^{*}Zp∗​内，aaa是生成元，求关于xxx的方程ax=ba^x=bax=b的解，并将解记作x=logabx=log_{a}{b}x=loga​b，离散对数指的就是这个logablog_{a}{b}loga​b.由于群Zp∗Z_{p}^{*}Zp∗​的阶是p−1p-1p−1,且是循...
离散对数问题——pohlig-hellman算法讲解(有例子)
热门推荐
因为一无所有，所以拥有无限可能。
01-22 1万+
写在前面 一切都要从去年8月的多校开始说起。 笔者在多校某场比赛中，遇到一个离散对数的题：HDU 6632 给定a,b,p(p∈prime,65537≤p≤1e18,2≤a,b≤p−1且p−1的质因子只能由2(和/或)3组成)a,b,p(p∈prime,65537\leq p \leq 1e18,2\leq a,b\leq p-1且p-1的质因子只能由2(和/或)3组成)a,b,p(p∈prime...
离散对数（同余理论-BSGS算法）
qq_41818544的博客
08-23 441
用来求解如下同余方程x的最小正整数解： p为质数，a、b、p已知，且 (如果a、b大于p，则对他们取模) 模板：（p为素数） /*********************解法***********************/ //BSGS算法 //求 a^x === b(mod p) 中的x值-----------当前p为素数...
离散对数求解、BSGS算法
nameofcsdn的博客
04-23 2824
目录 一，广义离散对数问题 二，广义离散对数问题的规约 三，shanks算法 四，OJ实战 一，广义离散对数问题 包括狭义的离散对数问题，和椭圆曲线上的点的数乘的逆运算，都算广义离散对数问题，他们的求解方案都差不多。 为了能够用统一的语言来描述，我们首先考虑，如何把广义离散对数问题，规约成狭义离散对数问题。 二，广义离散对数问题的规约 1，逆元 有限域中，元素的逆元可以用费马小定理+快速幂，a^(p-2)是a的逆元 椭圆曲线上，点A（x,y）的逆元是-A，即（x,-y） 2，基点的阶
【数学】扩展 BSGS
mango09の世界
11-07 286
前置芝士：BSGS 当 a,b,pa,b,pa,b,p 均为整数时，请求出方程 ax≡b(modp) a^x\equiv b\pmod p ax≡b(modp) 的最小非负整数解. 对于普通的 BSGS\rm BSGSBSGS，必须在 a,pa,pa,p 互质时才能求. 当 a,pa,pa,p 不互质时，需要用到扩展 BSGS\rm BSGSBSGS，即 exBSGS\rm exBSGSexBSGS. 我们考虑： ax≡b(modp)设gcd⁡(a,p)=g1axg1≡bg1(modpg1) a^x\equ
UVCCamera-master.rar_USB摄像头Android_android_giant master_it7x9_us
09-21
USB摄像头调试，Android应用，插入摄像头之后可以直接预览
vrp求解.rar_giant5a9_lie46y_拆分_运输vrp_运输车
07-15
matlab运用禁忌算法求解运输可拆分需求车辆不定的最佳路径，最佳车数
遗传算法.zip_giant5aa_is5cb_新安江_新安江 参数_遗传算法
07-14
新安江模型，应用遗传算法用于参数的自动率定
Simple Breakage.zip_API_EDEM_EDEM API_EDEM简单算例_giant2em
07-14
EDEM中简单破碎问题的用户自定义API算例
拓展BSGS
zixiangzhan的博客
03-03 343
拓展BSGS BSGS解决像这样的问题： 对于a,p,b,求解形如ax ≡b(mod p)的问题，其中a,p要求互质 对于a,p不互质的情况，我们引入拓展BSGS算法 一、BSGS算法（Baby Step,Giant Step) 1.前置性质 ax 对p的模随着x周期性变化，并且周期不大于p。根据鸽笼原理，由于 ax %p∈[0,p-1]值域大小为p，故x取1~p+1时必有两个ax 的余数是一样的，于是这两个x的差值绝对值就是周期。 若ax ≡b(mod p)有解 等价于 ax ≡b(mod p)在x∈
Mod Tree(扩展BSGS)
codeswarrior的博客
08-12 271
Mod Tree The picture indicates a tree, every node has 2 children. The depth of the nodes whose color is blue is 3; the depth of the node whose color is pink is 0. Now out problem is so easy, g...
Mod Tree
笑看风云起的专栏
06-05 568
Problem Description   The picture indicates a tree, every node has 2 children.   The depth of the nodes whose color is blue is 3; the depth of the node whose color is pink is 0.   Now out probl
离散对数基础
The future is already here it's just not evenly distributed。
05-23 6946
原文：http://abloz.com/tech/2018/06/27/discrete-logarithm/ 概念 同余运算 数学上，同余（congruence modulo，符号：≡）是数论中的一种等价关系。当两个整数除以同一个正整数，若得相同余数，则二整数同余。同余是抽象代数中的同余关系的原型。最先引用同余的概念与“≡”符号者为德国数学家高斯。 两个整数 a， b，若它们除以正...
离散对数求解算法
小周的专栏
01-21 1万+
///大步小步算法 struct baby///小步算法预存的结构体定义 { long long b,j; bool operator < (const baby &other)const{ return b<other.b; } }babyv[100005]; ///快速幂，x^y%mod long long q_pow(long long x,long
Hdu 2815 题解
莫莫 dicol 的博客
08-25 117
Hdu 2815 题解 Mod Tree 详解见我的博客 #include <bits/stdc++.h> using namespace std; //#define Fread //#define Getmod #ifdef Fread char buf[1 << 21], *iS, *iT; #define gc() (iS == iT ? (iT = (iS = buf) + fread (buf, 1, 1 << 21, stdin), (iS == iT
hdu——2815（数论之Baby Step Giant Step解决离散对数问题）
luoshenzhisi
08-16 1172
题目地址：http://acm.hdu.edu.cn/showproblem.php?pid=2815 可借鉴地址：http://blog.csdn.net/acm_cxlove/article/details/7832197 小结：可以说的上是个模板题。 #include #include #include #include #include #include using na
HDU2815 Mod Tree 高次同余方程
AC_Gibson的专栏
06-08 1184
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=2815 题目大意：一颗K叉树，让你找出最小的深度D，使该深度上的叶子数对P取模为N。 分析：高次同余方程K^D≡N（mod P）的求解问题。只是需要注意的是，如果N>P,那么显然是不存在的（这地方WA哭了）。 实现代码如下： #include #
hdu2815扩展小步大步攻击
执米之手，与米偕老
11-18 2719
题目 ： http://acm.hdu.edu.cn/showproblem.php?pid=2815 题目大意 ： 求解 a ^ x = b ( mod c)  (0 算法 ： 扩展小步大步攻击（AC大牛） 思路 ：在介绍扩展小步大步攻击之前， 先说两个要点 1 ：如 d = a % b, 则 Gcd(a, b) | d; 证明 ： d = a % b = a – a
巨量算数_signature
最新发布
05-12
巨量算数_signature（Giant Number Arithmetic Signature）是一种数字签名算法。数字签名是一种用于验证数据完整性和身份验证的技术。数字签名在计算机应用程序中广泛使用，特别是在电子邮件和电子商务中。 Giant ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值