线性同余方程组

写在前面：

　　记录了个人的学习过程，同时方便复习

　　笔者渣渣，网上的证明看不懂，只能自己证

　　注意不要把中国剩余定理和解线性同余方程组混为一谈

　　中国剩余定理仅仅是一个很巧妙的算法

　　在学习如何解线性同余方程组之前，根本没必要学习中国剩余定理

 

　　本篇全原创，转载请留言

 

目录

• 线性同余方程组是否有解

• 解的周期性

• 失败的尝试

• 解线性同余方程组

 

by otakuap

 

• 线性同余方程组是否有解

　　同余方程组的解什么时候存在呢？

　　先假设要解这么一个同余方程组：

　　　　x ≡ a₁ (mod b₁)

　　　　x ≡ a₂ (mod b₂)

　　　　……

　　　　x ≡ a_n (mod b_n)

　　　　我们假设其中的每一个同余方程都成立！

　　我在[◹]拓展欧几里得算法的应用④中提到了同余方程的一个有趣的性质：放缩性

　　利用放缩，我们来把所有的模数变成一样的！

　　　　定义B=Πⁿ_i=1 b_i

　　　　根据放缩，则上面那个同余方程组可以转化为：

　　　　x*B/b₁ ≡ a₁*B/b₁ (mod B)

　　　　x*B/b₂ ≡ a₂*B/b₂ (mod B)

　　　　……

　　　　x*B/b_n ≡ a_n*B/b_n (mod B)

　　在同余方程组中有这么一个显然的性质：

　　　　在同一模数的意义下，同一个数的对应值不能有多个！(在函数中可以多对一，不能一对多)

　　一旦出现

　　　　x*B/b_i ≡ c (mod B)

　　　　x*B/b_i ≡ d (mod B)

　　　　c，d为非负整数，且c!=d

　　那么一定无解

　　这就是同余方程组有解无解的本质了

　　在这里可以得到上面的线性同余方程组的成立条件：

① 每一组同余方程都有解

(详见[◹]拓展欧几里得算法应用④)

② 每一个x*B/b_i都唯一对应一个a_i*B/b_i

　　只要以上条件有一个不满足，那么这组同余方程一定无解！

　　在中国剩余定理解线性同余方程组中，模数两两互质

　　保证了对应的唯一性

　　这就是为什么中国国剩余定理来解线性同余方程组，要么不能解，要么一定有解

 

• 解的周期性

　　首先假设有多个周期函数f(x)，他们的周期分别为T_i

　　这多个周期函数方程组成的方程组的解的最小正周期为T

　　则显然，T为T_i的最小公倍数

 

　　同理

　　先假设要解这么一个同余方程组：

　　　　x ≡ a₁ (mod b₁)

　　　　x ≡ a₂ (mod b₂)

　　　　……

　　　　x ≡ a_n (mod b_n)

　　　　我们假设其中的每一个同余方程都成立！

　　利用放缩，我们来把所有的模数变成一样的！

　　　　定义B=LCM(b_i)

注意此处是最小公倍数而不单单是积

　　　　根据放缩，则上面那个同余方程组可以转化为：

　　　　x*B/b₁ ≡ a₁*B/b₁ (mod B)

　　　　x*B/b₂ ≡ a₂*B/b₂ (mod B)

　　　　……

　　　　x*B/b_n ≡ a_n*B/b_n (mod B)

　　解这么一组线性同余方程组，如果有解，那么它的最小非负整数解一定是[0，B-1]这个区间中的某个整数！

 

• 失败的尝试

某只马血的教训

　　先来看一个同余方程组中有趣的性质：

性质：

A1 ≡ B1 (mod C)

A2 ≡ B2 (mod C)

如果这两个同余式都成立，那么一定有：

A1+A2 ≡ (B1+B2)%C (mod C)

暂且叫这条性质为可加性

 

证明：

　　根据%运算的分配律

　　　　(a+b)%c == ((a%c)+(b%c))%C

　　则有

　　　　若a ≡ a%c (mod c)

　　　　b ≡ b%c (mod c)

　　　　则a+b ≡ ((a%c)+(b%c))%c (mod c)

　　这个尝试的思路，大概是先把模数都弄成一样的，然后转化出该线性同余方程组的最终同余方程

　　利用[◹]拓展欧几里得算法的应用④，判定这个最终方程有没有解，解出来是多少

　　　　如果有解，不能说明该线性同余方程组有解

　　　　如果无解，不能说明该线性同余方程组无解

　　为什么呢？

　　因为可加性的逆命题是假命题

　　举个例子：

　　　　x ≡ 2 (mod 3)

　　　　x ≡ 5 (mod 6)

　　　　x ≡ 2 (mod 7)

　　根据放缩，有

　　　　14x ≡ 28 (mod 42)

　　　　7x ≡ 35 (mod 42)

　　　　6x ≡ 12 (mod 42)

　　根据可加性，有

　　　　27x ≡ 33 (mod 42)

　　解得一个x==9

　　反带回去：

　　　　14*9 ≡ 0 (mod 42)

　　　　7*9 ≡ 21 (mod 42)

　　　　6*9 ≡ 12 (mod 42)

　　根本不成立

 

　　同余方程组中还有一个趣的性质：

性质：

A1 ≡ B1 (mod C)

A2 ≡ B2 (mod C)

如果这两个同余式都成立，那么一定有：

A1*A2 ≡ (B1*B2)%C (mod C)

暂且叫这条性质为可乘性

 

证明：

　　根据%运算的分配律

　　　　(a*b)%c == ((a%c)*(b%c))%C

　　则有

　　　　若a ≡ a%c (mod c)

　　　　b ≡ b%c (mod c)

　　　　则a*b ≡ ((a%c)*(b%c))%c (mod c)

　　和可加性一样，利用可乘性求解x的尝试也是失败的

　　因为可乘性的逆命题是假命题

　　举个例子：

　　　　x ≡ 5 (mod 6)

　　　　x ≡ 2 (mod 7)

　　根据放缩，有

　　　　7x ≡ 35 (mod 42)

　　　　6x ≡ 12 (mod 42)

　　根据可乘性，有

　　　　42x ≡ 0 (mod 42)

　　显然，x为任意整数

　　更别说什么反带回去了

 

　　虽然这两个尝试都失败了，但是它们还是很有价值的

 

• 解线性同余方程组

　　首先，在[◹]拓展欧几里得算法中提到的放缩的逆命题是真命题

　　其次，我们已经知道了什么情况下，待解的线性同余方程组有解

　　我们可以采用拆分，合并的解法来解决问题：

　　先假设要解这么一个同余方程组：

　　　　x ≡ a₁ (mod b₁)

　　　　x ≡ a₂ (mod b₂)

　　　　……

　　　　x ≡ a_n (mod b_n)

　　　　其中可能有些同余方程根本就没有解，详见[◹]拓展欧几里得算法

　　定义B=LCM(b_i)

　　根据放缩，则上面那个同余方程组可以转化为：

　　　　x*B/b₁ ≡ a₁*B/b₁ (mod B)

　　　　x*B/b₂ ≡ a₂*B/b₂ (mod B)

　　　　……

　　　　x*B/b_n ≡ a_n*B/b_n (mod B)

　　根据有无解的条件②，先判断有没有一对多的情况

　　　　如果有，那么肯定无解

　　　　如果没有，那么可能有解，继续

　　然后根据有无解的条件①，一个个判断有无 无解的同余方程 并求出x_i，x_i都是最小非负整数解

　　　　如果存在无解的同余方程，那么一定无解

　　　　如果不存在无解的同余方程，那么一定有解

 

待完成

 

#include<bits/stdc++.h>

using namespace std;

int const MAXN=10010;
int x,y,tmpb,tmpa,tmp,times;
int k;//k组同余方程
int a[MAXN];//每个同余方程的余数
int b[MAXN];//每个同余方程的模数
int bi[MAXN],ai[MAXN];
int B=1;

void C_swap(int &a,int &b){int c=a;a=b;b=c;return;}

int exgcd(int a,int b)
{
    if(!b){
        x=1;y=0;
        return a;
    }
    int ret=exgcd(b,a%b);
    int tmp=x;
    x=y;y=tmp-(a/b)*y;
    return ret;
}

int lcm(int a,int b){
    return a/exgcd(a,b)*b;
}

void ponySort(int l,int r){
    int i=l,j=r,mid=bi[(l+r)>>1];
    while(i<=j){
        while(bi[i]<mid) ++i;
        while(bi[j]>mid) --j;
        if(i<=j){
            C_swap(bi[i],bi[j]);
            C_swap(ai[i],ai[j]);
            ++i;--j;
        }
    }
    if(l<j) ponySort(l,j);
    if(i<r) ponySort(i,r);
    return;
}

int main(int argc,char *argv[],char *enc[])
{
    scanf("%d",&k);
    for(int i=1;i<=k;++i)
        scanf("%d%d",&b[i],&a[i]);
    
    for(int i=1;i<=k;++i)
        printf("x ≡ %d (mod %d)\n",a[i],b[i]);
    printf("\n");
    
    for(int i=1;i<=k;++i)
        B=lcm(B,b[i]);
    
    for(int i=1;i<=k;++i){
        bi[i]=B/b[i];
        ai[i]=B/b[i]*a[i];
    }
    
    for(int i=1;i<=k;++i)
        printf("x*%d ≡ %d (mod %d)\n",bi[i],ai[i],B);
    printf("\n");
    
    ponySort(1,k);
    
    for(int i=1;i<=k;++i)
        printf("x*%d ≡ %d (mod %d)\n",bi[i],ai[i],B);
    printf("\n");
    
    for(int i=1;i<=k;++i)
    {
        if(tmpa!=ai[i] && tmpb==bi[i]){
            printf("NOPE\n");
            return 0;
        }
        tmpa=ai[i];
        tmpb=bi[i];
    }
    
    /* xi*bi[i] ≡ ai[i] (mod B) */
    
    for(int i=1;i<=k;++i){
        
        tmp=exgcd(bi[i],B);
        
        if(ai[i]%tmp!=0){
            printf("NOPE\n");
            return 0;
        }
        else{
            times=0;
            while(ai[i]%tmp==0){
                ai[i]/=tmp;
                ++times;
            }
            
            if(tmp!=B){
                x*=ai[i];
                x=((x%(B/(tmp*times)))+(B/(tmp*times)))%(B/(tmp*times));
                printf("%d*%d ≡ %d (mod %d)\n",x,bi[i],ai[i]*times*tmp,B);
            }
            else{
                printf("NOPE\n");
                return 0;
            }
        }
    }
    
    return 0;
}
/*
3
3 2
6 5
7 2
*/