数论入门基础（同余定理/费马小定理/扩展欧几里德算法/中国剩余定理）～

最新推荐文章于 2021-11-28 12:09:00 发布

lxt_Lucia

最新推荐文章于 2021-11-28 12:09:00 发布

阅读量1.8k

点赞数 7

分类专栏： algorithm knowledge 文章标签：同余定理费马小定理 exgcd 中国剩余定理

knowledge 同时被 2 个专栏收录

42 篇文章 24 订阅

订阅专栏

algorithm

26 篇文章 28 订阅

订阅专栏

欢迎访问https://blog.csdn.net/lxt_Lucia～～

宇宙第一小仙女\(^o^)/～～萌量爆表求带飞=≡Σ((( つ^o^)つ~ dalao们点个关注呗～～

数论入门～～本文主要整理了一下同余定理/费马小定理/扩展欧几里德算法/中国剩余定理各自的概念描述、结论证明和模板应用，需要的可以参考一下咯～

一.同余定理

1.描述：

同余定理是数论中的重要概念。给定一个正整数m，如果两个整数a和b满足（a-b）能够被m整除，即（a-b）/m得到一个整数，那么就称整数a与b对模m同余，记作a≡b(mod m)。

2.符号：

两个整数a、b，若它们除以整数m所得的余数相等，则称a与b对模m同余或a同余于b模m。记作a≡b(mod m)

3.定义：

设m是大于1的正整数，a、b是整数，如果两个整数同时除以一个整数得到的余数相同，即m|(a-b)，则称a与b关于模m同余，记作a≡b(mod m)。显然有如下事实：

若a≡0(mod m)，则m|a;
a≡b(mod m)等价于a与b分别用m去除，余数相同。

4.证明 :

(1) 充分性：
若a和b用m相除留下相同的余数r，则 a=q1m+r, b=q2m+r,q1和q2为某两个整数，由此的a-b=(q1m+r)-(q2m-r)=m(q1-q2)，根据整除定义，我们有m|(a-b)，由同余式定义得出结论：a≡b(mod m)。

(2) 必要性：
若a和b用m相除留下相同的余数r，则 a=q1m+r,b=q2m+r,所以a-b=m(q1-q2) 故 m|(a-b)。

5.性质：

反身性：a≡a (mod m)
对称性：若a≡b(mod m)，则b≡a(mod m)
传递性：若a≡b(mod m)，b≡c(mod m)，则a≡c(mod m)
同余式相加：若a≡b(mod m)，b≡c(mod m)，则a ± c≡b ± d(mod m)
同余式相乘：若a≡b(mod m)，b≡c(mod m)，则ac≡bd(mod m)
线性运算：如果a≡b(mod m)，c≡d(mod m)，那么a ± c≡b ± d(mod m)，且a * c≡b * d(mod m)
除法：若ac ≡ bc (mod m) c≠0 则 a≡ b (mod m/gcd(c,m)) 其中gcd(c,m)表示c,m的最大公约数。特殊地 ,gcd(c,m)=1 则a ≡ b (mod m)
幂运算：如果a ≡ b (mod m)，那么a^n ≡ b^n (mod m)
若a ≡ b (mod m)，n|m,则 a ≡ b (mod n)
若a ≡ b (mod mi) (i=1,2…n) 则 a ≡ b (mod [m1,m2,…mn]) 其中[m1,m2,…mn]表示m1,m2,…mn的最小公倍数

6.应用：

(1)高精度对单精度取模

一个高精度数对一个数取余，可以把高精度数看成各位数的权值与个位数乘积的和。如1234 = ((1 * 10 + 2) * 10 + 3) * 10 + 4，对这个数进行取余运算就是上面基本加和乘的应用。

#include<iostream>
#include<string>
using namespace std;
 
int main(){
    string a;
    int b;
    cin >> a >> b;
    int len = a.length();
    int ans = 0;
    for(int i = 0; i < len; i++){
        ans = (ans * 10 + a[i] - '0') % b;
    }
    cout << ans << endl;
    return 0;
}

(2)快速幂取模

将幂拆解为多个底数的平方次的积，如果指数为偶数，把指数除以2，并让底数的平方次取余，如果指数为奇数，就把多出来的底数记录下来，再执行偶数次的操作。

#include<iostream>
using namespace std;
 
int PowerMod(int a, int b, int c){
    int ans = 1;
    a = a % c;
    while(b > 0){
        if(b&1){
            ans *= (a % c);
        }
        b >>= 1;
        a = (a * a) % c;
    }
    ans %= c;
    return ans;
}
 
int main()
{
    int a, b, c;
    cin >> a >> b >> c;
    cout << PowerMod(a, b, c) << endl;
    return 0;
}

二.费马小定理

1.费马小定理：

假如p是质数，且gcd(a,p)=1，那么 a(p-1)≡1（mod p）。即：假如a是整数，p是质数，且a,p互质(即两者只有一个公约数1)，那么a的(p-1)次方除以p的余数恒等于1。

2.同余证法：

任意取一个质数，比如13。考虑从1到12的一系列整数1,2,3,4,5,6,7,8,9,10,11,12，给这些数都乘上一个与13互质的数，比如3，得到3,6,9,12,15,18,21,24,27,30,33,36。对于模13来说，这些数同余于3,6,9,12,2,5,8,11,1,4,7,10。这些余数实际上就是原来的1,2,3,4,5,6,7,8,9,10,11,12，只是顺序不同而已。
把1,2,3,…,12统统乘起来，乘积就是12的阶乘12！。把3,6,9,…,36也统统乘起来，并且提出公因子3，乘积就是312×12！。对于模13来说，这两个乘积都同余于1,2,3,…,12系列，尽管顺序不是一一对应，即312×12！≡12！mod 13。两边同时除以12！得312≡1 mod 13。如果用p代替13，用x代替3，就得到费马小定理xp－1≡1 mod p。

以zoj3785为例：

It's Saturday today, what day is it after 1^1 + 2^2 + 3^3 + ... + N^N days? (1 <= N <= 1000000000).

对于

1^1     2^2     3^3     4^4     5^5     6^6     7^7
8^8     9^9     10^10   11^11   12^12   13^13   14^14
15^15   16^16   17^17   18^18   19^19   20^20   21^21
22^22   23^23   24^24   25^25   26^26   27^27   28^28
29^29   30^30   31^31   32^32   33^33   34^34   35^35
36^36   37^37   38^38   39^39   40^40   41^41   42^42
43^43   44^44   45^45   46^46   47^47   48^48   49^49

都对7取模后

1^1       2^2       3^3      4^4      5^5      6^6      0^7
1^8       2^9       3^10     4^11     5^12     6^13     0^14
1^15      2^16      3^17     4^18     5^19     6^20     0^21
1^22      2^23      3^24     4^25     5^26     6^27     0^28
1^29      2^30      3^31     4^32     5^33     6^34     0^35
1^36      2^37      3^38     4^39     5^40     6^41     0^42
1^43      2^44      3^45     4^46     5^47     6^48     0^49

根据费马小定理x6≡1（mod 7）可得

1^1     2^2       3^3       4^4       5^5      6^6       0
1^2     2^3       3^4       4^5       5^6      6^1       0 
1^3     2^4       3^5       4^6       5^1      6^2       0
1^4     2^5       3^6       4^1       5^2      6^3       0
1^5     2^6       3^1       4^2       5^3      6^4       0
1^6     2^1       3^2       4^3       5^4      6^5       0
1^1     2^2       3^3       4^4       5^5      6^6       0

每六行一个循环，循环节长度为42

#include<stdio.h>
#include<algorithm>
#include<iostream>
#include<string.h>
#include<stdlib.h>
#include<queue>
#include<vector>
#include<math.h>
#include<stack>
using namespace std;
const int MAX = 1000+10;
const double eps = 1e-10;
const double PI = acos(-1.0);
long long n;
int t;
int s[50];
int main()
{
    for(int i=1; i<=44; i++)
    {
        int flag=i%7;
        int ans=1;
        for(int j=1; j<=i; j++)
            ans=(ans*flag)%7;
        s[i]=ans;
    }
    for(int i=1; i<=44; i++)
        s[i]+=s[i-1];
    scanf("%d", &t);
    long long ans;
    while(t--)
    {
        scanf("%lld", &n);
        ans=(n/42%7*(s[42]%7)%7+s[n%42]%7)%7;
        ans = (ans+6)%7;
        if(ans==1)printf("Monday\n");
        else if(ans==2)printf("Tuesday\n");
        else if(ans==3)printf("Wednesday\n");
        else if(ans==4)printf("Thursday\n");
        else if(ans==5)printf("Friday\n");
        else if(ans==6)printf("Saturday\n");
        else printf("Sunday\n");
 
    }
    return 0;
}

三.欧几里德算法 and 扩展欧几里德算法(gcd and exgcd)

(一) 欧几里德算法 (gcd)

1.描述：

欧几里德算法又称辗转相除法，用于计算两个整数a,b的最大公约数。

2.基本算法：

设a=qb+r，其中a，b，q，r都是整数，则gcd(a,b)=gcd(b,r)，即gcd(a,b)=gcd(b,a%b)。

3.证明：

方法一：

a可以表示成a = kb + r，则r = a mod b

　　假设d是a,b的一个公约数，则有

　　d|a, d|b，而r = a - kb，因此d|r

　　因此d是(b,a mod b)的公约数

　　假设d 是(b,a mod b)的公约数，则

　　d | b , d |r ，但是a = kb +r

　　因此d也是(a,b)的公约数

　　因此(a,b)和(b,a mod b)的公约数是一样的，其最大公约数也必然相等，得证

方法二：

  要证欧几里德算法成立，即证: gcd(a,b)=gcd(b,r),其中 gcd是取最大公约数的意思，r=a mod b
    下面证 gcd（a，b）=gcd（b，r）
    设c是a，b的最大公约数，即c=gcd（a，b），则有 a=mc，b=nc，其中m，n为正整数，且m，n互为质数
    由 r= a mod b可知，r= a- qb 其中，q是正整数，
    则 r=a-qb=mc-qnc=（m-qn）c
    b=nc,r=(m-qn)c，且n，（m-qn）互质（假设n，m-qn不互质，则n=xd, m-qn=yd 其中x,y,d都是正整数，且d>1
  则a=mc=(qx+y)dc, b=xdc,这时a,b 的最大公约数变成dc，与前提矛盾，所以n ，m-qn一定互质）
    则gcd（b,r）=c=gcd（a,b）
    得证。

4.算法的实现：

(1)递归算法，代码：

int gcd(int a,int b)
{
    if(b==0)
        return a;
    return 
        gcd(b,a%b);
}

(2)优化如下：

int gcd(int a,int b)
{
    return b ? gcd(b,a%b) : a;
}

(3)用迭代形式：

int gcd(int a, int b)
{
    while(b != 0)
    {
    　　int r = b;
    　　b = a % b;
    　　a = r;
    }
    return a;
}

(二) 扩展欧几里德算法 (exgcd)

1.基本算法：

对于不完全为 0 的非负整数 a，b，gcd（a，b）表示 a，b 的最大公约数，必然存在整数对 x，y ，使得 gcd（a，b）=ax+by。

2.证明：

设 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;

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

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

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

3.算法的实现：

(1)递归代码：

int exgcd(int a,int b,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;
}

(2)非递归代码：

int exgcd(int m,int n,int &x,int &y)
{
    int x1,y1,x0,y0;
    x0=1; y0=0;
    x1=0; y1=1;
    x=0; y=1;
    int r=m%n;
    int q=(m-r)/n;
    while(r)
    {
        x=x0-q*x1; y=y0-q*y1;
        x0=x1; y0=y1;
        x1=x; y1=y;
        m=n; n=r; r=m%n;
        q=(m-r)/n;
    }
    return n;
}

4.应用:

（1) 解决不定方程：

对于不定整数方程pa+qb=c，若 c mod Gcd(p, q)=0,则该方程存在整数解，否则不存在整数解。
上面已经列出找一个整数解的方法，在找到p * a+q * b = Gcd(p, q)的一组解p0,q0后，p * a+q * b = Gcd(p, q)的其他整数解满足：
p = p0 + b/Gcd(p, q) * t
q = q0 - a/Gcd(p, q) * t(其中t为任意整数)
至于pa+qb=c的整数解，只需将p * a+q * b = Gcd(p, q)的每个解乘上 c/Gcd(p, q) 即可。

在找到p * a+q * b = Gcd(a, b)的一组解p0,q0后，应该是得到p * a+q * b = c的一组解p1 = p0*(c/Gcd(a,b)),q1 = q0*(c/Gcd(a,b))，

p * a+q * b = c的其他整数解满足：

p = p1 + b/Gcd(a, b) * t

q = q1 - a/Gcd(a, b) * t(其中t为任意整数)

p 、q就是p * a+q * b = c的所有整数解。

如，解不定方程ax+by=c代码：

bool linear_equation(int a,int b,int c,int &x,int &y)
{
    int d=exgcd(a,b,x,y);
    if(c%d)
        return false;
    int k=c/d;
    x*=k; y*=k;    //求得的只是其中一组解
    return true;
}

(2)求解模线性方程：

同余方程 ax≡b (mod n)对于未知数 x 有解，当且仅当 gcd(a,n) | b。且方程有解时，方程有 gcd(a,n) 个解。

求解方程 ax≡b (mod n) 相当于求解方程 ax+ ny= b, (x, y为整数)

设 d= gcd(a,n)，假如整数 x 和 y，满足 d= ax+ ny(用扩展欧几里德得出)。如果 d| b，则方程

a* x0+ n* y0= d，方程两边乘以 b/ d，(因为 d|b，所以能够整除)，得到 a* x0* b/ d+ n* y0* b/ d= b。
所以 x= x0* b/ d，y= y0* b/ d 为 ax+ ny= b 的一个解，所以 x= x0* b/ d 为 ax= b (mod n ) 的解。

ax≡b (mod n)的一个解为 x0= x* (b/ d ) mod n，且方程的 d 个解分别为 xi= (x0+ i* (n/ d ))mod n {i= 0... d-1}。

设ans=x*(b/d),s=n/d;

方程ax≡b (mod n)的最小整数解为：(ans%s+s)%s;

相关证明：

  证明方程有一解是: x0 = x'(b/d) mod n;
由 a*x0 = a*x'(b/d) (mod n)
         a*x0 = d (b/d) (mod n)   (由于 ax' = d (mod n))
                 = b (mod n)

  证明方程有d个解: xi = x0 + i*(n/d) (mod n);
由 a*xi (mod n) = a * (x0 + i*(n/d)) (mod n)
                             = (a*x0+a*i*(n/d)) (mod n)
                             = a * x0 (mod n)             (由于 d | a)
                             = b

首先看一个简单的例子：

5x=4(mod3)

解得x = 2,5,8,11,14.......

由此可以发现一个规律，就是解的间隔是3.

那么这个解的间隔是怎么决定的呢？

如果可以设法找到第一个解，并且求出解之间的间隔，那么就可以求出模的线性方程的解集了.

我们设解之间的间隔为dx.

那么有

a*x = b(mod n);

a*(x+dx) = b(mod n);

两式相减，得到:

a*dx(mod n)= 0;

也就是说a*dx就是a的倍数，同时也是n的倍数，即a*dx是a 和 n的公倍数.为了求出dx,我们应该求出a 和 n的最小公倍数,此时对应的dx是最小的.

设a 和 n的最大公约数为d,那么a 和 n 的最小公倍数为(a*n)/d.

即a*dx = a*n/d;

所以dx = n/d.

因此解之间的间隔就求出来了.

代码如下：

bool modular_linear_equation(int a,int b,int n)
{
    int x,y,x0,i;
    int d=exgcd(a,n,x,y);
    if(b%d)
        return false;
    x0=x*(b/d)%n;   //特解
    for(i=1;i<d;i++)
        printf("%d\n",(x0+i*(n/d))%n);
    return true;
}

(3)求模的逆元:

同余方程ax≡b (mod n)，如果 gcd(a,n)== 1，则方程只有唯一解。

在这种情况下，如果 b== 1，同余方程就是 ax=1 (mod n ),gcd(a,n)= 1。

这时称求出的 x 为 a 的对模 n 乘法的逆元。

对于同余方程 ax= 1(mod n )， gcd(a,n)= 1 的求解就是求解方程

ax+ ny= 1，x, y 为整数。这个可用扩展欧几里德算法求出，原同余方程的唯一解就是用扩展欧几里德算法得出的 x 。

四.中国剩余定理 ( 孙子定理 / CRT )

1.描述：

设正整数两两互素，则同余方程组

有整数解。并且在模下的解是唯一的，解为

其中，而为模的逆元。

2.代码实现：

(1)互质：

//求M%A=a,M%B=b,...中的M，其中A,B,C...互质
int CRT(int a[],int m[],int n){  
    int M = 1;  
    int ans = 0;  
    for(int i=1; i<=n; i++)  
        M *= m[i];  
    for(int i=1; i<=n; i++){  
        int x, y;  
        int Mi = M / m[i];  
        ex_gcd(Mi, m[i], x, y);  
        ans = (ans + Mi * x * a[i]) % M;  
    }  
    if(ans < 0) 
       ans += M;  
    return ans;  
}

(2)非互质：

一般的中国剩余定理要求mi两两互质，但是保证互质条件太苛刻了，若mi并不满足两两互质时，就要采用两两合并的思想，假设要合并如下两个方程
x=a1+m1*x1
x=a2+m2*x2

得到
a1+m1*x1 = a2+m2*x2 → m1*x1+m2*x2 = a2-a1

再通过扩展欧几里得算法解出x1的最小正整数解，代入
x=a1+m1*x1

得到x后合并为一个方程的结果为
y ≡ x(mod lcm(m1,m2))

这样一直合并下去，最终可以求得同余方程组的解。

代码：

bool merge(LL a1, LL m1, LL a2, LL m2, LL &a3, LL &m3)  {  
    LL d = gcd(m1, m2);  
    LL c = a2 - a1;  
    if(c % d) return false;  
    c = (c % m2 + m2) % m2;  
    m1 /= d;  
    m2 /= d;  
    c /= d;  
    c *= Inv(m1, m2);//Inv为乘法逆元，数论常用内容——欧几里得算法与扩展欧几里得算法
    c %= m2;  
    c *= m1 * d;  
    c += a1;  
    m3 = m1 * m2 * d;  
    a3 = (c % m3 + m3) % m3;  
    return true;  
}  

LL CRT(LL a[], LL m[], int n)  {  
    LL a1 = a[1];  
    LL m1 = m[1];  
    for(int i=2; i<=n; i++)  {  
        LL a2 = a[i];  
        LL m2 = m[i];  
        LL m3, a3;  
        if(!merge(a1, m1, a2, m2, a3, m3))  
            return -1;  
        a1 = a3;  
        m1 = m3;  
    }  
    return (a1 % m1 + m1) % m1;  
}

3.例题：

(1) POJ 1006

题意：

人自出生起就有体力，情感和智力三个生理周期，分别为23，28和33天。一个周期内有一天为峰值，在这一天，人在对应的方面（体力，情感或智力）表现最好。通常这三个周期的峰值不会是同一天。现在给出三个日期，分别对应于体力，情感，智力出现峰值的日期。然后再给出一个起始日期，要求从这一天开始，算出最少再过多少天后三个峰值同时出现。

代码：

#include <iostream>
#include <string.h>
#include <stdio.h>
 
using namespace std;
 
int a[4], m[4];
 
void extend_Euclid(int a, int b, int &x, int &y)
{
    if(b == 0)
    {
        x = 1;
        y = 0;
        return;
    }
    extend_Euclid(b, a % b, x, y);
    int tmp = x;
    x = y;
    y = tmp - (a / b) * y;
}
 
int CRT(int a[],int m[],int n)
{
    int M = 1;
    int ans = 0;
    for(int i=1; i<=n; i++)
        M *= m[i];
    for(int i=1; i<=n; i++)
    {
        int x, y;
        int Mi = M / m[i];
        extend_Euclid(Mi, m[i], x, y);
        ans = (ans + Mi * x * a[i]) % M;
    }
    if(ans < 0) ans += M;
    return ans;
}
 
int main()
{
    int p, e, i, d, t = 1;
    while(cin>>p>>e>>i>>d)
    {
        if(p == -1 && e == -1 && i == -1 && d == -1)
            break;
        a[1] = p;
        a[2] = e;
        a[3] = i;
        m[1] = 23;
        m[2] = 28;
        m[3] = 33;
        int ans = CRT(a, m, 3);
        if(ans <= d)
            ans += 21252;
        cout<<"Case "<<t++<<": the next triple peak occurs in "<<ans - d<<" days."<<endl;
    }
    return 0;
}

(2) POJ 2891

#include <iostream>
#include <string.h>
#include <stdio.h>
 
using namespace std;
typedef long long LL;
const int N = 1005;
 
LL a[N], m[N];
 
LL gcd(LL a,LL b)
{
    return b? gcd(b, a % b) : a;
}
 
void extend_Euclid(LL a, LL b, LL &x, LL &y)
{
    if(b == 0)
    {
        x = 1;
        y = 0;
        return;
    }
    extend_Euclid(b, a % b, x, y);
    LL tmp = x;
    x = y;
    y = tmp - (a / b) * y;
}
 
LL Inv(LL a, LL b)
{
    LL d = gcd(a, b);
    if(d != 1) return -1;
    LL x, y;
    extend_Euclid(a, b, x, y);
    return (x % b + b) % b;
}
 
bool merge(LL a1, LL m1, LL a2, LL m2, LL &a3, LL &m3)
{
    LL d = gcd(m1, m2);
    LL c = a2 - a1;
    if(c % d) return false;
    c = (c % m2 + m2) % m2;
    m1 /= d;
    m2 /= d;
    c /= d;
    c *= Inv(m1, m2);
    c %= m2;
    c *= m1 * d;
    c += a1;
    m3 = m1 * m2 * d;
    a3 = (c % m3 + m3) % m3;
    return true;
}
 
LL CRT(LL a[], LL m[], int n)
{
    LL a1 = a[1];
    LL m1 = m[1];
    for(int i=2; i<=n; i++)
    {
        LL a2 = a[i];
        LL m2 = m[i];
        LL m3, a3;
        if(!merge(a1, m1, a2, m2, a3, m3))
            return -1;
        a1 = a3;
        m1 = m3;
    }
    return (a1 % m1 + m1) % m1;
}
 
int main()
{
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        for(int i=1; i<=n; i++)
            scanf("%I64d%I64d",&m[i], &a[i]);
        LL ans = CRT(a, m, n);
        printf("%I64d\n",ans);
    }
    return 0;
}

(3) HDU 1573

分析：

这个题由于数据范围小，那么直接可以通过枚举在这个数的最小公倍数范围内的所有数，找到最小的正整数解，然后后面的所有解都可以通过这个得到。

代码：

#include <iostream>
#include <string.h>
#include <stdio.h>
 
using namespace std;
const int N = 25;
 
int a[N], b[N];
 
int gcd(int a, int b)
{
    return b ? gcd(b, a % b) : a;
}
 
int main()
{
    int T;
    cin>>T;
    while(T--)
    {
        int n, m;
        cin>>n>>m;
        for(int i=0; i<m; i++)
            cin>>a[i];
        for(int i=0; i<m; i++)
            cin>>b[i];
        int lcm = 1;
        for(int i=0; i<m; i++)
            lcm = lcm / gcd(lcm, a[i]) * a[i];
        bool f = 1;
        for(int i=1; i<=lcm&&i<=n; i++)
        {
            f = 1;
            for(int j=0; j<m; j++)
            {
                if(i % a[j] != b[j])
                    f = 0;
            }
            if(f)
            {
                printf("%d\n",(n - i) / lcm + 1);
                break;
            }
        }
        if(f == 0)
            printf("0\n");
    }
    return 0;
}

参考资料：

https://blog.csdn.net/zcy_2016/article/details/55054146

https://blog.csdn.net/acdreamers/article/details/8050018

https://blog.csdn.net/tick_tock97/article/details/71313058

https://blog.csdn.net/qq_36345036/article/details/77407069

https://blog.csdn.net/QQ1353217816/article/details/79706975

http://www.cnblogs.com/frog112111/archive/2012/08/19/2646012.html