【数学】中国剩余定理

最新推荐文章于 2024-10-05 21:03:21 发布
最新推荐文章于 2024-10-05 21:03:21 发布
阅读量1.6k 收藏 1
点赞数 3
分类专栏： 数学 文章标签： 数学 中国剩余定理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35713030/article/details/82316961
版权

特殊情况

我们先来看一下问题，现在有n个同余方程组（如下图）
这里写图片描述
其中m两两互质。
求解。
问题很简单，结论也很简单，我们用构造的思路来想一想，能不能整一个解x，使得其有每个方程的一部分，但是当x%mi时除了第i个方程的部分以外都被%成0，即x%mi=ai,这是可以的.
这里写图片描述
(源自百度，很清楚了)
由于aitiMi%mj=0(i!=j).且aitiMi%mi=ai.
所以x%mi=ai;
但这不仅仅是我现在想讲的，因为在很多的题目中，m往往并不互质。这时怎么办呢？
我们只有换一下思路了。

一般情况

不再考虑整个一起求，那样会变得十分的麻烦。很明显如果能够将2个方程合并成一个，那么问题就解决了。
已知：
x mod m[1] = r[1]；
x mod m[2] = r[2]；
根据这两个式子，存在两个整数k[1],k[2]：
x = m[1] * k[1] + r[1]
x = m[2] * k[2] + r[2]
由于两个方程的左边都是x，因此有：
m[1] * k[1] + r[1] = m[2] * k[2] + r[2]
m[1] * k[1] - m[2] * k[2] = r[2] - r[1]
由于m[1],m[2],r[1],r[2]都是常数，若令A=m[1],B=m[2],C=r[2]-r[1],x=k[1],y=k[2]，
则上式变为：Ax + By = C。
可以用exgcd求出 k[1] ，k[2]
再把k[1]代入x = m[1] * k[1] + r[1]，就可以求解出x。
接下来我们将这个x作为特解，扩展出一个解系：
X = x + t*lcm(m[1], m[2]) t为整数，lcm(a,b)表示a和b的最小公倍数
将其改变形式为：
X mod lcm(m[1], m[2]) = x
令M = lcm(m[1], m[2]), R = x，则有新的模方程X mod M = R
经过上述步骤，我们将x mod m[1] = r[1] x mod m[2] = r[2]
这两个方程合并为了一个新方程X mod lcm(m[1], m[2]) = x；
至此，问题的理论基础就完成了。
看看例题：

一.poj1006:Biorhythms

题目是英文，翻译过来就是：
人自出生起就有体力，情感和智力三个生理周期，分别为23，28和33天。一个周期内有一天为峰值，在这一天，人在对应的方面（体力，情感或智力）表现最好。通常这三个周期的峰值不会是同一天。
现在给出三个日期，分别对应于体力，情感，智力出现峰值的日期。然后再给出一个起始日期，要求从这一天开始，算出最少再过多少天后三个峰值同时出现。
说白了n=3时的特殊情况。

二.HDU1573:X问题

中文题，自己看。
这道题就是一道板题。代码如下：

#include<cstdio>
#include<cstring>
#include<vector>
#include<queue>
#include<algorithm>
using namespace std;
const long long MAXN=15;
long long N,M1,m[MAXN],r[MAXN];
long long gcd(long long a,long long b)
{
    return a%b==0?b:gcd(b,a%b);
}
void exgcd(long long a,long long b,long long &x,long long &y)
{
    if(b==0)
    {
        x=1,y=0;
        return ;
    }
    long long xx,yy;
    exgcd(b,a%b,xx,yy);
    x=yy;
    y=xx-(a/b*yy);
}
int main()
{
    long long T;
    scanf("%lld",&T);
    while(T--)
    {
        scanf("%lld %lld",&N,&M1);
        for(long long i=1;i<=M1;i++)
            scanf("%lld",&m[i]);
        for(long long i=1;i<=M1;i++)
            scanf("%lld",&r[i]);
        long long R=r[1],M=m[1],d,c,k1,k2;
        int key=0;
        for(long long i=2;i<=M1;i++)
        {
            d=gcd(M,m[i]);
            c=r[i]-R;
            if(c%d)
            {
                key=1;
                break;
            }
            exgcd(M/d,m[i]/d,k1,k2);
            k1=(c/d*k1)%(m[i]/d);
            R=R+k1*M;
            M=M/d*m[i];
            R%=M;
        }
        if(R<0)
            R=R%M+M;
        if(key||R>N)
            printf("0\n");
        else
        {
            if(R==0)
                printf("%lld\n",N/M);
            else
                printf("%lld\n",(N-R)/M+1);
        }
    }
}
三.hihocoder1303 : 数论六·模线性方程组

这道题还是一道板题。代码如下：

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const long long MAXN=1005;
long long n,m[MAXN],r[MAXN];
long long gcd(long long a,long long b)
{
    return a%b==0?b:gcd(b,a%b);
}
void exgcd(long long a,long long b,long long &x,long long &y)
{
    if(b==0)
    {
        x=1,y=0;
        return ;
    }
    long long xx,yy;
    exgcd(b,a%b,xx,yy);
    x=yy;
    y=xx-(a/b*yy);
}
int main()
{
    scanf("%lld",&n);
    for(long long i=1;i<=n;i++)
    {
        scanf("%lld %lld",&m[i],&r[i]);
    }
    long long R=r[1],M=m[1],d,c,k1,k2;
    for(long long i=2;i<=n;i++)
    {
        d=gcd(M,m[i]);
        c=r[i]-R;
        if(c%d)
            return -1;
        exgcd(M/d,m[i]/d,k1,k2);
        k1=(c/d*k1)%(m[i]/d);
        R=R+k1*M;
        M=M/d*m[i];
        R%=M;
    }
    if(R<0)
        R=R+M;
    printf("%lld",R);
}
四.HDU3579：Hello Kiki

题意：给定N组数(ai, ri)。求一个最小的正整数K，满足所有的K mod ai = ri。
这道题还是一道板题，但是题目要求正整数，所以不能是0，如果是0最后要加M。

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const long long MAXN=1005;
long long n,m[MAXN],r[MAXN];
long long gcd(long long a,long long b)
{
    return a%b==0?b:gcd(b,a%b);
}
void exgcd(long long a,long long b,long long &x,long long &y)
{
    if(b==0)
    {
        x=1,y=0;
        return ;
    }
    long long xx,yy;
    exgcd(b,a%b,xx,yy);
    x=yy;
    y=xx-(a/b*yy);
}
int main()
{
    long long T,tt=0;
    scanf("%I64d",&T);
    while(T--)
    {
        scanf("%I64d",&n);
        for(long long i=1;i<=n;i++)
            scanf("%I64d",&m[i]);
        for(long long i=1;i<=n;i++)
            scanf("%I64d",&r[i]);
        long long R=r[1],M=m[1],d,c,k1,k2,key=0;
        for(long long i=2;i<=n;i++)
        {
            d=gcd(M,m[i]);
            c=r[i]-R;
            if(c%d)
            {
                key=1;
                break;
            }
            m[i]=m[i]/d;
            c=c/d;
            exgcd(M/d,m[i],k1,k2);
            k1=((c*k1)%m[i]+m[i])%m[i];
            R=R+k1*M;
            M=M*m[i];
            R=(R%M+M)%M;
        }
        tt++;
        printf("Case %I64d: ",tt);
        R=(R+M)%M;
        if(key==0)
        {
            if(R==0)
                R=M;
            printf("%I64d\n",R);
        }
        else
            printf("-1\n");
    }
}
五.[NOI2018 D2T1]屠龙勇士

首先，对于每一条龙，我们都可以知道我们要用哪一把剑，这个可以直接map查找完成，在确定了用哪一把剑后，我们在知道了龙的血量A[i],恢复力m[i]，和我们的攻击力xs[i]后（字母乱打的，勿喷）。可以知道这样一个等式：A[i]-X * xs[i]=0(mod m[i]),移项得A[i]=X * xs[i](mod m[i])所以先同时约去公因数后求出xs[i]在mod m[i]意义下的逆元可得X=A[i]*(xs[i])^-1(mod m[i])这样就有n个方程了，用中国剩余定理解决即可。
下面是代码。

#include<cstdio>
#include<map>
#include<vector>
#include<cstring>
#include<algorithm>
using namespace std;
const long long MAXN=100005,INF=9223372036854775807ll;
long long n,m;
long long A[MAXN],M[MAXN],get[MAXN],xs[MAXN];
map<long long,int>nowj;
long long ksc(long long x,long long y,long long MOD)
{
    long long re=0;
    if(y<0)
        x=-x,y=-y;
    while(y)
    {
        if(y&1)
            re=(re+x)%MOD;
        x=(x+x)%MOD;
        y>>=1;
    }
    return re;
}
long long gcd(long long a,long long b)
{
    return a%b==0?b:gcd(b,a%b);
}
long long exgcd(long long a,long long b,long long &x,long long &y)
{
    if(b==0)
    {
        x=1,y=0;
        return a;
    }
    long long q=exgcd(b,a%b,y,x);
    y-=a/b*x;
    return q;
}
long long findny(long long a,long long m)
{
    long long x=0,y=0;
    exgcd(a,m,x,y);
    return x;
}
int main()
{
    //freopen("dragon.in","r",stdin);
    //freopen("dragon.out","w",stdout);
    long long T;
    scanf("%lld",&T);
    while(T--)
    {
        memset(A,0,sizeof(A));
        memset(M,0,sizeof(M));
        memset(get,0,sizeof(get));
        nowj.clear();
        long long mi=0;//保证砍mi刀所有的龙血量都小于等于0
        scanf("%lld %lld",&n,&m);
        for(long long i=1;i<=n;i++)
            scanf("%lld",&A[i]);
        for(long long i=1;i<=n;i++)
            scanf("%lld",&M[i]);
        for(long long i=1;i<=n;i++)
            scanf("%lld",&get[i]);
        for(long long i=1;i<=m;i++)
        {
            long long e;
            scanf("%lld",&e);
            nowj[e]++;
        }
        nowj[-1]++;//哨兵节点
        for(long long i=1;i<=n;i++)
        {
            map<long long,int>::iterator it;
            it=nowj.upper_bound(A[i]);
            it--;
            if(it->first==-1)
                it++;
            xs[i]=it->first;
            it->second--;
            if(it->second==0)
                nowj.erase(it);
            nowj[get[i]]++;
        }
        for(long long i=1;i<=n;i++)
        {
            int GG=gcd(gcd(A[i],M[i]),xs[i]);
            A[i]/=GG;
            M[i]/=GG;
            xs[i]/=GG;
            mi=max(((A[i]+xs[i]-1)/xs[i]),mi);
            long long ny=findny(xs[i],M[i]);
            A[i]=(ksc(A[i],ny,M[i])+M[i])%M[i];
            xs[i]=1;
        }
        long long key=0;
        for(long long i=1;i<n;i++)
        {
            long long a1=A[i],a2=A[i+1],n1=M[i],n2=M[i+1];
            long long c=(a2-a1)%n2,D=gcd(n1,n2);
            if(c%D!=0)
            {
                key=1;
                break;
            }
            long long ny=findny(n1/D,n2/D);
            long long K=(ksc(c/D,ny,(n2/D))+(n2/D))%(n2/D);
            long long zm=n1/D*n2;
            long long za=ksc(n1,K,zm)+a1;
            za=(za%zm+zm)%zm;
            A[i+1]=za;
            M[i+1]=zm;
        }
        if(!key)
        {
            long long X=A[n];
            X=(X%M[n]+M[n])%M[n];
            if(X<mi)
            {
                int cc=(mi-X+M[n]-1)/M[n];
                X+=cc*M[n];
            }
            printf("%lld\n",X);
        }
        else
            printf("-1\n");
    }
    //fclose(stdin);
    //fclose(stdout);
}
六.HDU1788:Chinese remainder theorem again

题意：给定数组Mi和数字a，求一个最小的数K，满足K mod mi = (mi - a)。
这道题很明显可以用中国剩余定理直接做，但是既然a都一样，会不会有什么巧妙的方法呢？
我们把每个式子合并一下看看。
x mod m[1] = -a；
x mod m[2] = -a；
根据这两个式子，存在两个整数k[1],k[2]：
x = m[1] * k[1] -a;
x = m[2] * k[2] -a;
由于两个方程的左边都是x，因此有：
m[1] * k[1] -a= m[2] * k[2] -a;
m[1] * k[1] - m[2] * k[2] = 0;
即
m[1] * k[1] =m[2] * k[2];
令 K=m[i]*k[i];
所以很明显x=K-a;
这样我们来看一下这个K，很明显K是所有m[i]的倍数，用于题目要求x最小，因此K为所有m的最小公倍数，最后答案是K-a

#include<cstdio>
#include<cstring>
#include<vector>
#include<queue>
#include<algorithm>
using namespace std;
long long n,a;
long long gcd(long long a,long long b)
{
    return b==0?a:gcd(b,a%b);
}
int main()
{
    while(~scanf("%lld %lld",&n,&a)&&n&&a)
    {
        long long M=1,m=0;
        for(long long i=1;i<=n;i++)
        {
            scanf("%lld",&m);
            M=M/gcd(M,m)*m;
        }
        printf("%lld\n",M-a);
    }
}
七.HDU3430:Shuffling

题意：给定一种重排规则A[N]，A[i]表示将第A[i]个数放到第i个位置（1<=i<=N）。然后给定一个目标状态，问从起始状态到达目标状态，最少需要经过多少步。
想用置换群？只用置换群一步步的变上去是会T的，在算出起始状态和目标的置换群后先看一下是否一样。如果不一样，直接-1，如果一样，就可以列方程了，比如(12)(345)(6)到(21)(534)(6)可得
x=1(mod2)
x=2(mod 3)
x=0(mod1)
然后用中国剩余定理解出答案即可
。

#include<cstdio>
#include<cstring>
#include<vector>
#include<queue>
#include<algorithm>
using namespace std;
const long long MAXN=10005;
long long n;
long long z[MAXN],a[MAXN],b[MAXN],ca[MAXN],cb[MAXN];
long long m[MAXN],r[MAXN];
long long vis[MAXN];
long long gcd(long long a,long long b)
{
    return a%b==0?b:gcd(b,a%b);
}
void exgcd(long long a,long long b,long long &x,long long &y)
{
    if(b==0)
    {
        x=1,y=0;
        return ;
    }
    long long xx,yy;
    exgcd(b,a%b,xx,yy);
    x=yy;
    y=xx-(a/b*yy);
}
void dfs(long long *A,long long *B,long long now)
{
    if(A[B[now]])
        return ;
    A[B[now]]=B[a[now]];
    dfs(A,B,a[now]);
}
void dfs1(long long now,long long id,long long dep,long long s)
{
    if(vis[now])
    {
        m[id]=dep;
        return ;
    }
    vis[now]=1;
    if(b[now]==s)
        r[id]=dep;
    dfs1(a[now],id,dep+1,s);
}
int main()
{
    while(~scanf("%lld",&n)&&n)
    {
        memset(vis,0,sizeof(vis));
        memset(ca,0,sizeof(ca));
        memset(cb,0,sizeof(cb));
        memset(m,0,sizeof(m));
        memset(r,0,sizeof(r));
        for(long long i=1;i<=n;i++)
        {
            long long u;
            scanf("%lld",&u);
            a[u]=i;
        }
        for(long long i=1;i<=n;i++)
        {
            scanf("%lld",&b[i]);
            z[i]=i;
        }
        for(long long i=1;i<=n;i++)
        {
            dfs(ca,z,i);
            dfs(cb,b,i);
        }
        long long key=0;
        for(long long i=1;i<=n;i++)
        {
            if(ca[i]!=cb[i])
            {
                printf("-1\n");
                key=1;
                break;
            }
        }
        if(key)
            continue;
        long long tot=0;
        for(long long i=1;i<=n;i++)
        {
            if(!vis[i])
            {
                ++tot;
                dfs1(i,tot,0,i);
            }
        }
        long long R=r[1],M=m[1],d,c,k1,k2;
        key=0;
        for(long long i=2;i<=tot;i++)
        {
            d=gcd(M,m[i]);
            c=r[i]-R;
            if(c%d)
            {
                printf("-1\n");
                key=1;
                break;
            }
            exgcd(M/d,m[i]/d,k1,k2);
            k1=(c/d*k1)%(m[i]/d);
            R=R+k1*M;
            M=M/d*m[i];
            R%=M;
        }
        if(key)
            continue;
        if(R<0)
            R=R%M+M;
        printf("%lld\n",R);
    }
}
jyzryz
关注
专栏目录
【中国剩余定理】
tystrwor的博客
03-30 304
中国剩余定理（CRT）的表述如下 设正整数两两互素，则同余方程组                               有整数解。并且在模下的解是唯一的，解为                                 其中，而为模的逆元。 代码：[cpp] view plain copy int CRT(int a[],int m[],int n)  {      int M = 1;...
中国剩余定理（CRT）
qq_42815397的博客
10-27 3282
一.前言 中国剩余定理，又称中国余数定理，是数论中的一個关于一元线性同余方程组的定理，说明了一元线性同余方程组有解的准则以及求解方法。也称为孙子定理，古有「韩信点兵」、「孙子定理」、「求一术」（宋 沈括）、「鬼谷算」（宋 周密）、「隔墙算」（宋 周密）、「剪管术」（宋 杨辉）、「秦王暗点兵」、「物不知数」之名。目前在大数据、云计算、RSA密码等邻域也发挥着重大作用。 二.例子 物不知数 在《孙子算经》中有这样一个问题：“今有物不知其数，三三数之剩二（除以3 余2）， 五五数之剩三（除以5 余3）
中国剩余定理：
_Griefs
08-24 484
一、标版： 题目描述 现有两组数字，每组k个，第一组中的数字分别为：a1，a2，…，ak表示，第二组中的数字分别用b1，b2，…，bk表示。其中第二组中的数字是两两互素的。求最小的非负整数n，满足对于任意的i，n - ai能被bi整除。 输入输出格式 输入格式： 输入数据的第一行是一个整数k，（1 ≤ k ≤ 10）。接下来有两行，第一行是：a1，a2，…，ak，第二行是b1，b2，…，bk 输出...
中国剩余定理专题
最新发布
Kent的博客
10-05 395
按照m之间的性质来决定采用什么方法是否互质？互质——中国剩余定理不互质——拓展欧几里得 + 拓展中国剩余定理互质情况下，是否均为质数？是—— 费马小定理求逆元否——拓展欧几里得求逆元。
中国剩余定理
呦呦鹿鸣n的博客
05-15 264
中国剩余定理详解模板：/*long long gcd(LL a,LL b) { return b==0?a:gcd(b,a%b); }*/ #include&lt;cstdio&gt; #define ll long long //扩展欧几里得算法 void gcd(ll a,ll b,ll &amp;d,ll &amp;x,ll &amp;y) { if(b==0){ ...
2_中国剩余定理_信息安全数学基础_
09-30
在信息安全数学基础中，中国剩余定理被用于设计高效且安全的加密算法。例如，在RSA公钥密码系统中，选择大素数p和q并计算它们的乘积n=pq，然后利用中国剩余定理可以快速地进行幂运算，提高加密和解密的速度。此外，...
Python实现的中国剩余定理算法示例
09-21
中国剩余定理的数学表述如下： 假设我们有\( k \)个正整数\( m_1, m_2, ..., m_k \)，并且这些整数两两互质（即任意两个数的最大公约数为1）。设\( M = m_1 \cdot m_2 \cdot ... \cdot m_k \)，那么对于任意一组...
秘密共享方案_中国剩余定理
11-15
#某电信安数学基础实验（3）基于中国剩余定理的秘密共享方案（更新）： #涉及位数的均为二进制位 #python #使用中国剩余定理 #使用（t,n）门限来控制秘密，即：n个子秘密中任取t个或以上即可计算得到秘密，而任意t-1...
数学知识：中国剩余定理
佛系更新
05-31 1174
文章目录前言一、中国剩余定理二、AcWing 204. 表达整数的奇怪方式本题解析AC代码三、时间复杂度 前言 复习acwing算法基础课的内容，本篇为讲解数学知识：中国剩余定理，关于时间复杂度：目前博主不太会计算，先鸽了，日后一定补上。 一、中国剩余定理 即孙子定理，具体定理即推导见：孙子定理，注意中国剩余定理必须要求两两互质，本博客例题中没有限制两两互质，故不能直接套用中国剩余定理的公式，需要在基础之上进行变形 二、AcWing 204. 表达整数的奇怪方式 本题链接：AcWing 204. 表.
关于中国剩余定理
dengrong849567的博客
03-10 85
用于处理类似的同余方程 $$ans=\left\{\begin{matrix}x\equiv a_{1}(\mod m_{1})\\ x\equiv a_{2}(\mod m_{2})\\ ......\\ x\equiv a_{n}(\mod m_{n})\end{matrix}\right.$$如果整数 $m_1,m_2...m_n$ 两两互质，则对任意整数 $a_1,a_2,.....
剩余定理
agcfka3579的博客
04-02 133
剩余问题 在整数除法里，一个数同时除以几个数，整数商后，均有剩余；已知各除数及其对应的余数，从而要求出适合条件的这个被除数的问题，叫做剩余问题。 解法（基础数法） 基础数的条件： （1）此数必须符合除数自身的余数条件； （2）此数必须是其他所有各除数的公倍数。 第一步：求各除数的最小公倍数 [3，5，7]=105 第二步：求各除数的基础数 （1）[3] ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值