运用模逆运算（同余方程）来解决Matlab课上的一道思考题

原作者: [db:作者] 来自: [db:来源] 收藏邀请

一道Matlab编程题 & 暴力解法

Matlab课上老师出了这样一道题：

一个篮子有K个鸡蛋：
2个2个拿剩1个；
3个3个全部拿完；
4个4个拿剩1；
5个5个拿剩4个；
6个6个拿剩3个；
7个7个拿全部拿完；
8个8个拿剩1个；
9个9个拿全部拿完；
求篮子里鸡蛋的个数K

虽然这是一道matlab拿来玩的题目，可是我觉得完全可以拿来做笔试题或者面试题。仔细想还是有点考算法能力的。

这道题直观地想是非常简单的，简单一想就可以发现鸡蛋个数一定是7，9，3的最小公倍数63的N倍，然后我们就可以把63的倍数枚举出来，然后分别与除以2~9的除数，判断余数是否是对应值就可以了。当然你也可以用点观察法，当然你可以通过一点简单的观察来得到结果的规律来减少枚举次数。

matlab的算法代码如下：

resultNum = [];
    resultIndex = 0;
    i = 1;
    while 63*i < 1000000000
        while 1
            i = i + 2;
            if max(abs(rem(63*i, inputDivisors) - modResult)) == 0
                break
            end 
        end
        resultNum(resultIndex + 1) = 63*i;
        resultIndex = resultIndex +1;
    end
    disp(resultIndex)
    resultNum( resultIndex)

如果把这道题目一般化，比如有N个鸡蛋，i次i次拿，拿M次，然后求鸡蛋个数在N以内的取值。那枚举肯定是最慢的方法了，算法复杂度一眼看出来就是O(MN) 。显然，当M和N都很大时，这个时间复杂度是很大的，我们要想个办法把它简化。

从另一个角度看问题

我们先来看下枚举本身为什么会慢的问题，我们可以看到，枚举每一次都要尝试和M个除数进行相除，然后得到余数，除了本身求余这种对CPU的ALU指令非常不友好导致速度有瓶颈以外，还有最致命的就是枚举要通过不断地 “试验” 来得到判断的目的，当然这个过程可以裁枝（就像上面所说的观察法），但是这个问题的裁枝也只是减少了复杂度MN前面的常数系数。

既然裁枝的方法是制约着整个整个算法的瓶颈，那么我们要想能不能不裁枝，而是通过直接用一个一定成立的方程（也就是算子）来推出所有的结果呢？

我们可以联想到算勾股定理（找出A^2 + B^2 == C^2）所有成立的公式的时候，这是某些Java书里面最喜欢考的弱鸡算法题了，第一眼反应的时候肯定是用个三重循环来枚举（复杂度O(N^3)），仔细想一下，可以用Hash表裁枝（复杂度O(N^2)），但是我们如果使用的是完全平方公式4M^2N^2 == (M^2 + N^2)^2 - (M^2 - N^2)^2来思考这道题，我们可以发现我们只用枚举O(sqrt(M^2 + N^2)*sqrt(M^2 - N^2))次（也就是O(N)）就可以找到所有的结果了，因为我们已经构建了一个一定成立的算子来填充结果了，而不需要再用枚举去匹配。

同样的，我们这道算法题也可以用同样的思路，我们观察一下可以得到，如果一个式子要满足结果对M个除数的余数都是成立的，那么结果必然是某些余数为0的除数的倍数。而根据余数定理可知，一个式子的对某个数的余式一定是一个多项式，所以我们立马就可以得到我们的结果一定是满足某个多项式的。如果能得到结果的算子，那么我们只要往算子里面填数据就可以得到所有的答案了。

寻找结果的多项式算子

首先第一步我们要确定多项式的系数，根据我们上面说的那样，这一题的答案一定是63*[polynomial]，然后我们继续观察，根据拿两个剩一个这个条件，答案必须是mod 2 == 1，那么由于63中不含有2，那么[polynomial]必须形如2k+?(?是任意数)，所以我们可以得到我们的答案一定是63*(2k + ?)；同理，根据拿四个剩一个这个条件，答案必须是mod 4== 1，在前面的基础上，我们的答案必须形如63*(2(2k + j) + i) = 63*(4k + 2j +i)....

经过一系列分析，我们可以得到如下过程：

step1: 63k
step2: 63*(2k + i)
step3: 63*(2(2k + j) + i) = 63*(4k + 2j + i)
step4: 63*(4(5k + l) + 2j + i) = 63*(20k + 4l + 2j + i)
step5: 63*(20(k + m) + 20l + 2j + i) = 63*(20k + 20m + 4l + 2j + i)
step6: 63*(20(2k + n) + 20m + 4l + 2j + i) = 63*(40k + 20n + 20m + 4l + 2j + i)

其中i, j, l, m, n都是大于等于0的任意整数

我们可以很清楚地看到我们想要的多项式的系数就是所有除数的最小公倍数，至此我们已经找到了我们想要的答案的第一部分了。

接下来我们要确定我们在多项式中的未定系数i, j, l, m, n，不过其实做到这里我们已经可以看到答案了，因为我们只要按暴力解法找出我们想要的第一个解（比如本题的最小鸡蛋数是1449），我们就可以确定我们想要的常数就是23了，也就是答案的算子为63*(40n + 23) (n >= 0)。这样做当然是可以的，而且这样做肯定比暴力解法来的快，复杂度褪化为O(M*C + N)（C为找到第一个解所需要的时间）。

但是我不想这么做，因为这样如果第一个解需要迭代的时间较长，或者根本本题根本无解，那么这样做会导致我们要算很久或者根本直接没有结果，我想直接把算子的常数直接推出来，而且还能判断是否有解。怎么做呢？我们可以利用同余方程来迅速求解。

用同余方程寻找多项式算子中的常数

同余方程（也称扩展欧几里得公式或者模逆运算，反正是一个意思）是数论里面最著名的东西了，同余方程描述如下：

设存在方程 ax + by = L

如果该方程的线性同余形式为 ax = L mod b

如果这个形式下该方程有解，那么L一定且仅满足gcd(a,b) == L时成立

同余方程有三个性质：

定理一：如果d = gcd(a, b)，则必能找到正的或负的整数k和l，使d = ax+ by。

定理二：若gcd(a, b) = 1，则方程ax ≡ c (mod b)在[0, b-1]上有唯一解。

定理三：若gcd(a, b) = d，则方程ax ≡ c (mod b)在[0, b/d - 1]上有唯一解。

如果得到ax ≡ c (mod b)的某一特解X，那么令r = b/gcd(a, b)，可知x在[0, r-1]上有唯一解，所以用x = (X % r + r) % r就可以求出最小非负整数解x了！（X % r可能是负值，此时保持在[-(r-1), 0]内，正值则保持在[0, r-1]内。加上r就保持在[1, 2r - 1]内，所以再模一下r就在[0, r-1]内了）。

有了同余方程我们可以很简单地求出我们所需要的常数了，在同余方程的描述中，我们所想要的东西为逆元，我们只需要稍微拓展一下我们的辗转相除法就可以了。每一次求匹配除数都要算一次逆元。

%External Euclidean Algorithm
%xPtr is a pointer, x is p(1), y is p(2) 
%warnning: the index is different from C\C++
function  result = ExMyGcd(n,m, xPtr)
    if n == 0
        find= m;
        xPtr.value(1) = 1;
        xPtr.value(2) = 0;
    else
        num=[0,0];
        numPtr=libpointer('int32Ptr', num);
        find = ExMyGcd(rem(m,n), n, numPtr);
        
        xPtr.value(1) = numPtr.value(2);
        xPtr.value(2) = numPtr.value(1) -  numPtr.value(2)*floor(m/n);
    end
    result = find;
end %ExMyGcd

xptr是一个指针，最后我们的逆元就是在xPtr.value(1)中！

另外通过同余方程的描述我们可以很快地判断题目的答案是否存在，因为我们的L，也就是余数，必须等于gcd(a,b)，如果不满足这个条件，也就表明我们无法找到一个逆元使我们的同余方程成立，自然也就不可能找到我们所想要的算子了。

完整的算法描述如下（我使用了OOP，用matlab里面的类做了一层封装,由于matlab里面的类的get和set太反人类了，我直接把属性做成public用了）

1. main.m

obj =  SearchPolyFuntionHelper(inputDivisors, modResult, 1, 1, 0);
    obj =  DoSearch(obj);
    n = 0;
    if obj.m_isValid == 0
        disp('invalid condition')   %不满足同余定理的条件，直接舍弃
    else
        coefficient =  obj.m_coefficient;
        innerCofficient = obj.m_innerCofficient;
        offset = obj.m_offset;
    
        resultNum = [];
        resultIndex = 0;
        while 1
            r = coefficient *(innerCofficient * n + offset);
            if (r  >=1000000000)
                break
            end
            resultNum(resultIndex + 1) = r;
            resultIndex = resultIndex + 1;
            n = n + 1;
        end
        disp(resultIndex)
        resultNum( resultIndex)
    end

2. SearchPolyFuntionHelper.m

classdef SearchPolyFuntionHelper
   methods (Access = 'public')
       function obj = SearchPolyFuntionHelper(divisors, modResult, coefficient, innerCofficient, offset)
            obj.m_divisors = divisors;
            obj.m_modResult = modResult;
            obj.m_coefficient = coefficient;
            obj.m_innerCofficient = innerCofficient;
            obj.m_offset = offset;
            obj.m_isValid = 1;
            
       end % SerchPolyFuntionHelper
       
       function obj =  DoSearch(obj)
           sum = size(obj.m_divisors);
           for n = 1: sum(2)
               if obj.m_modResult(n) == 0
                   mCoefficient = obj.m_coefficient;
                   mDivisors  = obj.m_divisors(n);
                   gcdDivisor = gcd(mCoefficient, mDivisors);
                   if gcdDivisor ~= mDivisors
                        obj.m_coefficient = mCoefficient*mDivisors / gcdDivisor;
                   end
               end
               n = n + 1;
           end
           for n = 1: sum(2)
               if obj.m_modResult(n) ~= 0
                   obj = Expand(obj, n);
                   
                   if obj.m_isValid ==0
                       return
                   end
               end
               n = n + 1;
           end
       end %DoSearch
   end
    methods(Access = 'private')   
        %Expand the cofficent
        function dObj =Expand(dObj, index)
            %先确定最小公倍数
            mDivisors = dObj.m_divisors(index);
            gcdDivisor = gcd(dObj.m_coefficient * dObj.m_innerCofficient, mDivisors);
            
            oldInnerCofficient = dObj.m_innerCofficient;
            dObj.m_innerCofficient = oldInnerCofficient * mDivisors / gcdDivisor;

            %确定偏移量 coefficient*oldInnerCofficient*i + offset ( i>=0)
            mod = dObj.m_modResult(index);
            offset = dObj.m_offset;
            
            offsetMod = rem(offset * dObj.m_coefficient, mDivisors); %得到偏移量的余数
            lastMod = rem(mod - offsetMod + mDivisors, mDivisors);
            
            if lastMod ~=0  %如果当前offset已经可以满足余数，就不需要再加了
                num=[0,0];
                xPtr=libpointer('int32Ptr',num);
                mul = dObj.m_coefficient* oldInnerCofficient;
                gcdDivisor =  ExMyGcd(mDivisors, mul, xPtr);
                
                if rem(lastMod, gcdDivisor) ~=0
                    dObj.m_isValid = 0; %如果不满足同余定理，说明无法找到这样的多项式，直接退出
                    return;
                end
                
                newCofficient= xPtr.value(1);
                newCofficient = newCofficient * lastMod/ gcdDivisor;
                dObj.m_offset = newCofficient* oldInnerCofficient + offset;
            end
        end%Expand
    end  
    properties (Access = 'public')
        m_coefficient;
        m_innerCofficient;
        m_offset;
        m_divisors;
        m_modResult;
        m_isValid;
        ElementIndex;
    end
   properties (Dependent)  
      Modulus  
   end  
end

3. ExMyGcd.m

%External Euclidean Algorithm
%xPtr is a pointer, x is p(1), y is p(2) 
%warnning: the index is different from C\C++
function  result = ExMyGcd(n,m, xPtr)
    if n == 0
        find= m;
        xPtr.value(1) = 1;
        xPtr.value(2) = 0;
    else
        num=[0,0];
        numPtr=libpointer('int32Ptr', num);
        find = ExMyGcd(rem(m,n), n, numPtr);
        
        xPtr.value(1) = numPtr.value(2);
        xPtr.value(2) = numPtr.value(1) -  numPtr.value(2)*floor(m/n);
    end
    result = find;
end %ExMyGcd

新的算法的时间复杂度分析

新的算法已经可以找到多项式了，所以复杂度是简单的O(MK + N)，现在的问题就是确定K的大小，也就是确定同余方程找逆元的大小，因为我写的同余方程是基于欧几里得算法的，所以我们只需要找到欧几里得算法的复杂度就可以了！

在不考虑模运算本身的时间复杂度下，我们只考虑这样的问题: 欧几里得算法在最坏情况下所需的模运算次数和输入的a和b的大小有怎样的关系?

我们不妨设a>b≥1, 构造数列{un}:

显然, 若算法需要n次模运算, 则有我们比较数列{un}和菲波那契数列{Fn},

以此类推，由数学归纳法容易得到

也就是

于是得到，也就是说如果欧几里得算法需要做n次模运算, 则b必定不小于Fn−1. 根据斐波那契数列的性质, 有

即 ,所以模运算的次数为O(lgb)

由此我们得到了我们算法的时间复杂度为O(Mlog(D) + N)，由于logD（D是最大的除数）的增长速率缓慢，所以时间复杂度可以看成是O(M + N)。

性能测试

暴力算法与用同余方程的算法在需要算出n以内鸡蛋数的条件下，进行时间复杂度的比较结果。

测试完整代码：（注意两个测试的结果数会相差1，因为我自己写的原因，暴力解法永远会多一个，不影响最后的结果）

clear
clc
mainFun()
function mainFun()
    modResult = [1,0,1,4,3,0,1,0];
    inputDivisors = [2:9];
    
    disp('-----------------Mytest-----------------')
    tic;
    obj =  SearchPolyFuntionHelper(inputDivisors, modResult, 1, 1, 0);
    obj =  DoSearch(obj);
    n = 0;
    if obj.m_isValid == 0
        disp('invalid condition')   %不满足同余定理的条件，直接舍弃
    else
        coefficient =  obj.m_coefficient;
        innerCofficient = obj.m_innerCofficient;
        offset = obj.m_offset;
    
        resultNum = [];
        resultIndex = 0;
        while 1
            r = coefficient *(innerCofficient * n + offset);
            if (r  >=1000000000)
                break
            end
            resultNum(resultIndex + 1) = r;
            resultIndex = resultIndex + 1;
            n = n + 1;
        end
        disp(resultIndex)
        resultNum( resultIndex)
    end

    toc;
    vpa(tic  - toc);
    
    disp('-----------------OridnaryTest-----------------')
    tic;
    resultNum = [];
    resultIndex = 0;
    i = 1;
    while 63*i < 1000000000
        while 1
            i = i + 2;
            if max(abs(rem(63*i, inputDivisors) - modResult)) == 0
                break
            end 
        end
        resultNum(resultIndex + 1) = 63*i;
        resultIndex = resultIndex +1;
    end
    disp(resultIndex)
    resultNum( resultIndex)
    toc;
    vpa(tic  - toc);
end

结果：

同余方程解法比暴力解法在n很大的情况下要快好几百倍

reference:

http://www.cnblogs.com/yueshuqiao/archive/2011/08/23/2150960.html

http://blog.csdn.net/xiamentingtao/article/details/44702869

鲜花

握手

雷人

路过

鸡蛋

该文章已有0人参与评论

请发表评论

全部评论

专题导读

More+

10-27 六六分期app的软件客服如何联系？(六六分期

11-06 可心卡盟:win10系统火狐flash插件崩溃怎么

11-06 亲亲特价:怎么删除回收站图标

11-06 济南大学虚拟社区:鲁大师节能降温的具体办

11-06 xlueops.exe:无线网络安装向导

11-06 女斗合众国:win7系统cf与主机连接不稳定怎

11-06 0xc000022-[cf烟雾头]cf怎么调烟雾头

11-06 qizideyouhuo:应用程序无法正常启动0xc0000

11-06 ipz-185:win7系统vcf文件怎么打开

11-06 傻哥蹦迪:win10系统s4怎么打开usb调试

11-06 八神浩树gtaste:回收站清空了怎么恢复

11-06 妖尾之黑色守护:win10系统电脑没有1440x900

11-06 校园至尊魔王小说:win7系统浏览网页时字体

11-06 女斗合众国:win10系统访问共享文件夹提示请

11-06 tokyo hot n0654:恢复win7系统默认字体一招

11-06 雨酷仙境:设置win7系统转移临时文件夹腾出

11-06 阿穆纳伊之杖:win7系统开始菜单在右边还原

11-06 tunespotting:win10系统火狐flash插件总是

11-06 甘尔葛分析师：计谋网站seo关键词暴涨有什

11-06 蔡贵霖: 计谋网站seo关键词暴涨有什么秘密

11-06 博益网首页:ao3网页版进入不了解决方法

11-06 漏斗子专栏: 网站数据分析小白易懂精华篇

11-06 见证双虹怎么做:win7系统开启telnet命令的

11-06 颾狐蝶蜋:系统资源不足无法完成请求的服务

11-06 国光中学校歌:提交网站到alexa查询详细步骤

11-06 西安有情天:静态网页和动态网页的区别

11-06 红木雅尚斋:外部链接构造对网站的好处

11-06 前官礼遇：防止域名劫持–增强域安全性的10

11-06 密传二转答案: 中文分词算法有哪些

11-06 金泉家园邮编:百度快照劫持的表现及应对方

delphi用webservice发布时间：2022-07-18

Delphi7下SuperObject的JSON使用方法发布时间：2022-07-18

剪的笔顺,诠释剪的笔画,认识剪的部首

1 六六分期app的软件客服如何联系？(六六分期

六六分期app的软件客服如何联系？不知道吗？加qq群【895510560】即可！标题：六六分期

阅读：19165|2023-10-27

2 可心卡盟:win10系统火狐flash插件崩溃怎么

今天小编告诉大家如何处理win10系统火狐flash插件总是崩溃的问题，可能很多用户都不知

阅读：9981|2022-11-06

3 亲亲特价:怎么删除回收站图标

今天小编告诉大家如何对win10系统删除桌面回收站图标进行设置，可能很多用户都不知道

阅读：8320|2022-11-06

4 济南大学虚拟社区:鲁大师节能降温的具体办

今天小编告诉大家如何对win10系统电脑设置节能降温的设置方法，想必大家都遇到过需要

阅读：8690|2022-11-06

5 xlueops.exe:无线网络安装向导

我们在使用xp系统的过程中,经常需要对xp系统无线网络安装向导设置进行设置，可能很多

阅读：8634|2022-11-06

6 女斗合众国:win7系统cf与主机连接不稳定怎

今天小编告诉大家如何处理win7系统玩cf老是与主机连接不稳定的问题，可能很多用户都不

阅读：9650|2022-11-06

7 0xc000022-[cf烟雾头]cf怎么调烟雾头

电脑对日常生活的重要性小编就不多说了，可是一旦碰到win7系统设置cf烟雾头的问题，很

阅读：8617|2022-11-06

8 qizideyouhuo:应用程序无法正常启动0xc0000

我们在日常使用电脑的时候，有的小伙伴们可能在打开应用的时候会遇见提示应用程序无法

阅读：7994|2022-11-06

9 ipz-185:win7系统vcf文件怎么打开

今天小编告诉大家如何对win7系统打开vcf文件进行设置，可能很多用户都不知道怎么对win

阅读：8648|2022-11-06

10 傻哥蹦迪:win10系统s4怎么打开usb调试

今天小编告诉大家如何对win10系统s4开启USB调试模式进行设置，可能很多用户都不知道怎

阅读：7531|2022-11-06

客服电话

电子邮件

运用模逆运算（同余方程）来解决Matlab课上的一道思考题

请发表评论

全部评论

上一篇：

下一篇：

librespeed/speedtest: Self-hosted Speedt

avehtari/BDA_m_demos: Bayesian Data Anal

四维彩超怎么看性别？四维看男孩女孩诀窍

medfreeman/markdown-it-toc-and-anchor: m

C#Matlab混合编程类初始化问题解决方法

剪的笔顺,诠释剪的笔画,认识剪的部首

六六分期app的软件客服如何联系？(六六分期

florent37/ViewAnimator: A fluent Android

florent37/Shrine-MaterialDesign2: implem

CVE-2020-36276

SimpleSoftwareIO/simple-sms: Send and re

关于我们

产品与服务

解决方案

139-2527-9053