同余方程 2012年NOIP

题目描述 Description

求关于 x 同余方程 ax ≡ 1 (mod b)的最小正整数解。 

输入描述 Input Description

输入只有一行，包含两个正整数 a, b，用 一个 空格隔开。 

输出描述 Output Description

输出只有一行包含一个正整数x0，即最小正整数解，输入数据保证一定有解。

样例输入 Sample Input

3 10 

样例输出 Sample Output

7

数据范围及提示 Data Size & Hint

【数据范围】
对于 40%  的数据， 2 ≤b≤ 1,000 ；
对于 60% 的数据， 2 ≤b≤ 50,000,000 
对于 100%  的数据， 2 ≤a, b≤ 2,000,000,000

解法一：

在此之前，先来了解一下欧几里德的辗转相除法的扩展：

对于不完全为 0 的非负整数 a，b，gcd（a，b）表示 a，b 的最大公约数，必然存在整

数对 x，y ，使得 gcd（a，b）=ax+by。

c++语言实现

1 2 3 4 5 6 7 8 9 10 11 12

int exGcd(inta,intb, int *x, int *y){ if (b==0){ x=1; y=0; return a; } int r=exGcd(b,a%b,x,y); int t=x; x=y; y=t-a/b*y; return r; }

求解 x，y的方法的理解

设 a>b。

1，显然当 b=0，gcd（a，b）=a。此时 x=1，y=0；

2， ab<>0 时

设 ax1+by1=gcd(a,b);

bx2+(a mod b)y2=gcd(b,a mod b);

根据朴素的 欧几里德原理有 gcd(a,b)=gcd(b,a mod b);

则:ax1+by1=bx2+(a mod b)y2;

即:ax1+by1=bx2+(a-[a/b]*b)y2=ay2+bx2-[a/b]*by2;

也就是ax1+by1==ay2+b(x2-[a/b]*y2);

根据恒等定理得：x1=y2; y1=x2-[a/b]*y2;

这样我们就得到了求解 x1,y1 的方法：x1，y1 的值基于 x2，y2.

上面的思想是以递归定义的，因为 gcd 不断的递归求解一定会有个时候 b=0，所以递归可以结束。

所以可得，a*x+b*y==1，然后求x。

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <cmath>
using namespace std;
int x,y,a,b;
int kzgcd(int a1,int b1){
if(b1==0){x=1;y=0;return a1;}
else {
int ans=kzgcd(b1,a1%b1);
int t=x;
x=y;
y=t-(a1/b1)*y;
return ans;
}
}
int main()
{
    cin>>a>>b;
int ans=kzgcd(a,b);
if (ans!=1) cout<<"No answer"<<endl;  
    else  
    {  
        x=x%b;  
        while (x<0) x+=b;  
        cout <<x<<endl;  
   }  
    return 0;
}

解法二：

假设我们知道了[0~block-1]内  i*a%b的值。

然后把接区间分成

blcok~ 2*block-1

2*block ~ 3*block -1

3*block~ 4*block -1

......................

假设解释y，那么 y 一定可以表示为 i*block+r (0<=r<=block-1)

y*a%b = (i*block +r)*a%b  = 1

那么  r *a%b = (1-i*block*a%b)  

我们枚举一个i ，就能得出等号右边的值 ，这是我们只需要找到最小的r，能否满足r*a%b,因为之前已经对0~block-1 内的数*a%b做过预处理，

那么不妨使用一个map做映射，这样就可以快速找r了。

[cpp]  view plain copy

1. #include <iostream>  
2. #include <cstdio>  
3. #include <cstdlib>  
4. #include <cstring>  
5. #include <algorithm>  
6. #include <map>  
7. using namespace std;  
8. typedef long long LL;  
9. const LL UP = 2000000000LL;  
10. const LL block = 100000;  
11. map<LL, int> mp;  
12. LL a,b,c;  
13. int main()  
14. {  
15.     cin>>a>>b;  
16.     mp.clear();  
17.     for (LL i = 0; i < block; ++i)  
18.     {  
19.         LL ans = i * a % b;  
20.         if (ans == 1) { cout << i <<endl; return 0;}  
21.         if (mp.find(ans) == mp.end()) mp[ans] = i;  
22.     }  
23.       
24.     for (LL i = block; i<=UP; i+=block)  
25.     {  
26.         LL c = (1LL - a *  i) % b;  
27.         if (c<0) c+=b;  
28.         if (mp.find(c) != mp.end())  
29.         {  
30.             cout<< i + mp[c] << endl;  
31.             return 0;        
32.         }  
33.     }  
34.     return 0;  
35. }