关于中国剩余定理

中国剩余定理

一、中国剩余定理

对于k个两两互质的正整数：(m_1,m_2,...,m_k)，任意k个正整数：(a_1, a_2, ..., a_k)，一个未知数x，如果满足一下一次同余式组：

[left{ egin{aligned} x &≡ a_1(mod m_1) \ x &≡ a_2(mod m_2) \ &......\ x &= a_k(mod m_k) end{aligned} ight. ]

定义：

(M = m_1*m_2*...*m_k)

(M_i = M/m_i)

(M_i^{-1})表示(mod m_i)意义下的逆元（即：(M_i * M_i^{-1} ≡ 1(mod m_i))）

则其解为：

(x = a_1*M_1*M_1^{-1} + a_1*M_1*M_1^{-1} + ... + a_k*M_k*M_k^{-1})

代码：

#include <iostream>

using namespace std;

typedef long long LL;

const int N = 100;

LL exgcd(LL a, LL b, LL &x, LL &y)
{
    if(!b)
    {
        x = 1, y = 0;
        return a;
    }
    
    LL d = exgcd(b, a % b, y, x);
    y -= (a / b) * x;
    return d;
}

LL CRT(LL a[], LL m[], int n)
{
	LL M = 1;
	for(int i = 0; i < n; i++) M *= m[i];
	
	LL res = 0;
	for(int i = 0; i < n; i++)
	{
		LL x, y;
		LL M_i = M / m[i]; 
		LL d = exgcd(M_i, m[i], x, y);
		res = (res + a[i] * M_i * x) % M;
	}
	
	return (res + M) % M;
}
  
int main()
{
	LL a[N], m[N];
	
    int n;
    cin >> n;
    
    for(int i = 0; i < n; i++)
    	scanf("%lld%lld", &a[i], &m[i]);
    
    cout << CRT(a, m, n) << endl;
    
    return 0;
}

二、利用拓展欧几里得求解一次同余式组

当(m_i)不满足两两互质时可以利用拓展欧几里得求解

推导过程：

对于两个同余式：

(left{ egin{aligned} x &≡ m_1(mod a_1) \ x &≡ m_2(mod a_2) \ end{aligned} ight.) 可得出：(left{ egin{aligned} x &= k_1 * a_1 + m_1 \ x &= k_2 * a_2 + m_2 \ end{aligned} ight.) 进一步可得出：(k_1 * a_1 - k_2 * a_2 = m_2 - m_1)

要使该方程有解则：(gcd(a_1, a_2) | m_2 - m_1)

令(d = gcd(a_1, a_2))，由拓展欧几里得定理可以求出方程的一个解为：(k_1 = k * (m_2 - m_1) / d)（其中，k为(k_1 * a_1 - k_2 * a_2 = gcd(k_1, k_2))的一个解），然后将其化为最小正整数解。

注：由于拓展欧几里得的通解为：(K = k + s * a_2/d(s为任意整数))，令(t = a_2/d)，则最小正整数解为：((k\%t + t)\%t)

将方程中的(k_1、k_2)换元为：(left{ egin{aligned} k_1 &= k_1 + k * a_2 / d \ k_2 &= k_2 + k * a_1 / d\ end{aligned} ight.)，带入原式可以得出：(x = (k_1 + k * a_2/d) * a_1 + m_1)，展开得：(x = a_1*k_1 + m_1 + k*lcm(a_1, a_2))

令(a = lcm(a_1, a_2), m = a_1*k_1 + m_1)，则：(x = k * a + m)

由此，两个同余式即化为了一个同余式，反复通过此方法，即可把n个同余式合并成1个，最终求出解。

代码：

#include <iostream>
#include <algorithm>

using namespace std;

typedef long long LL;

LL exgcd(LL a, LL b, LL &x, LL &y)
{
    if(!b)
    {
        x = 1, y = 0;
        return a;
    }
    
    LL d = exgcd(b, a % b, y, x);
    y -= (a / b) * x;
    return d;
}

int main()
{
    int n;
    cin >> n;
    
    bool has_answer = true;
    //作为第一组数据，同时存储每次合并后的结果
    LL a1, m1;
    cin >> a1 >> m1;
    
    for(int i = 0; i < n-1; i++)
    {
        LL a2, m2;
        scanf("%lld%lld", &a2, &m2);
        
        LL k1, k2;
        LL d = exgcd(a1, a2, k1, k2);
        
        if((m2 - m1) % d)
        {
            has_answer = false;
            break;
        }
        //求出一个解
        k1 *= (m2 - m1) / d;
        //求出最小整数解
        LL t = a2 / d;
        k1 = (k1 % t + t) % t;
        //更新合并后的a1、m1
        m1 = a1 * k1 + m1;
        a1 = abs(a1 / d * a2);
    }
    //最小整数解
    if(has_answer) cout << (m1 % a1 + a1) % a1 << endl;
    else puts("-1");
    
    return 0;
}

三、应用

广场上有一队士兵，如果排成10 列纵队，最后剩下a 个人((0 leq a leq 9))；如果排成9 列纵队，最后剩下b 个人((0 leq b leq 8))；如果排成8 列纵队，最后剩下c 个人((0 leq c leq 7))……如果排成2 列纵队，最后剩下i 个人((0 £ leq i leq 1))，输入a, b, c,…, i，输出广场上士兵的最少可能人数

设一共有x个士兵，由题意可以得出9个方程：(left{ egin{aligned} x \% 10 &= a_1 \ x \% 9 &= a_2 \ &...\ x \% 2 &= a_9end{aligned} ight.)，则：(left{ egin{aligned} x &≡ a_1(mod 10) \ x &≡ a_2(mod 9) \ &......\ x &= a_9(mod 2) end{aligned} ight.)，即题目转化为求一次同余式组。由于给出的模数并不是两两互质的，所以采用拓展欧几里得算法求解该问题。

代码：

#include <iostream>

using namespace std;

typedef long long LL;

LL exgcd(LL a, LL b, LL &x, LL &y)
{
    if(!b)
    {
        x = 1, y = 0;
        return a;
    }
    
    LL d = exgcd(b, a % b, y, x);
    y -= (a / b) * x;
    return d;
}

int main()
{
    int n;
    cin >> n;
    
    int a[10];
    cout << "请输入a~i：";
	for(int i = 0; i < 9; i++)
		scanf("%d", &a[i]);
		
    bool has_answer = true;
    //作为第一组数据，同时存储每次合并后的结果
    LL a1 = 10, m1 = a[0];
    
    for(int i = 0; i < n-1; i++)
    {
        LL a2 = 10 - i - 1, m2 = a[i + 1];
        
        LL k1, k2;
        LL d = exgcd(a1, a2, k1, k2);
        
        if((m2 - m1) % d)
        {
            has_answer = false;
            break;
        }
        //求出一个解
        k1 *= (m2 - m1) / d;
        //求出最小整数解
        LL t = a2 / d;
        k1 = (k1 % t + t) % t;
        //更新合并后的a1、m1
        m1 = a1 * k1 + m1;
        a1 = abs(a1 / d * a2);
    }
    //最小整数解
    if(has_answer) cout << (m1 % a1 + a1) % a1 << endl;
    else puts("-1");
    
    return 0;
}