关于数的高次幂运算取余，解决大数溢出问题

解决思路

当一个幂运算很大，而模为整型数时，通常的做法（先求幂再取模），结果很大可能就是数溢出，无法表示这样的大数，导致运算失败。 可以先试着将数分割成几个部分，然后一个部分一部分的求取模数，从而实现目的。

引用基础数学公式

可以用数学公式解决的问题，千万别去计算能力暴力解决。因为可以用公式解决的问题，时间空间的复杂度很可能直接就是O(1)

公式1证明：

数学公式：
$$(a\ast b)modC=((amodC)\ast b)modC;(a,b,C皆是是整数)$$
设：a=m+k, m 的值为 C 的 n 倍数（n>=0，且为整数）, k < C
则:
$$\begin{array}{rl}(a\ast b)modC& =((m+k)\ast b)modC\\ & =(mb+kb)modC\\ & =(Cnb+kb)modC\\ & =kbmodC\end{array}$$
因为：
$$k=amodC$$
所以：
$$(a\ast b)modC=((amodC)\ast b)modC$$

公式2证明：

数学公式
$$a\ast bmodC=(amodC)\ast (bmodC)modC(a,b,C皆是是整数)$$
设：$$a=m+k_1,b=n+k_2,m,n的值为C的x倍数（x>=0，且为整数）,k_1,k_2<C$$
则：
$$\begin{array}{rl}a\ast b& =(m+k_1)\ast (n+k_2)\\ & =mn+m{k}_2+k_{1}n+k_1{k}_2\\ 由于& m和n都是C的x倍得到：\\ & =C{x}_{1}C{x}_2+C{x}_1{k}_2+k_{1}C{x}_2+k_1{k}_{2}modC\\ & =k_1{k}_{2}modC\\ k_1& =amodC\\ k_2& =bmodC\\ 可得：& \\ a\ast bmodC& =(amodC)\ast (bmodC)modC\end{array}$$

公式3证明：

数学公式：
$$a^{b}modC=(amodC{)}^{b}modC(a,b,C皆是是整数)$$

设：$$a=m+k,m的值为C的n倍数（b,n>=0，且为整数）,k<C$$

则根据牛顿二项式展开得到:
$$\begin{array}{rl}{a}^{b}modC& =(m+k{)}^{b}modC\\ & =\left(\sum _{i=0}^b{d}_i{m}^{b-i}{k}^i\right)modC\\ & =(d_0{m}^b+d_1{m}^{b-1}k+d_2{m}^{b-2}{k}^2+d_3{m}^{b-3}{k}^3+\cdots +d_{b-1}m{k}^{b-1}+d_b{k}^b)modC\\ & \\ d_0,d_1,d_2,d_3\cdots d_b>0& 且都是整数（牛顿二项式系数）\end{array}$$
因为 $d_0,d_b=1$ 所以得到：
$$(m^b+d_1{m}^{b-1}k+d_2{m}^{b-2}{k}^2+d_3{m}^{b-3}{k}^3+\cdots +d_{b-1}m{k}^{b-1}+k^b)$$
前 b 项全换成C的倍数形式，得到
$$\begin{array}{rl}& ((Cn{)}^b+d_1(Cn{)}^{b-1}k+d_2(Cn{)}^{b-2}{k}^2+d_3(Cn{)}^{b-3}{k}^3+\cdots +d_{b-1}(Cn)k^{b-1}+k^b)modC\\ & =k^{b}modC\\ k& =amodC\end{array}$$
所有的C的倍数全被排除了，所以：
$$\begin{array}{r}{a}^{b}modC=(amodC{)}^{b}modC\end{array}$$

猜想，但我无法证明

任意一个质数a, 任何一个小于a且大于0的整数d,
则有：$$d^{a}moda=d$$

大数分解

如：$a^b$ mod C 求解 (a, b, C 皆是是整数)

1. 首先把 b 转化成二进制
   如：$$b_0,b_1,b_2,b_3,b_4\cdots b_{31}$$
   即：$$b＝b_0\ast 2^{31}+b_1\ast 2^{30}+b_2\ast 2^{29}+\cdots +b_{31}\ast 2^0;$$
   也就是把
   $$\begin{array}{rl}{a}^b& =a^{(b_0\ast 2^{31}+b_1\ast 2^{30}+\cdots +b_{31})}\\ & =a^{(b_0\ast 2^{31})}\ast a^{(b_1\ast 2^{30})}\ast a^{(b_2\ast 2^{29})}.....\ast a^{(b_{31}\ast 2^0)};\end{array}$$
   例如：$8^{25}$ mod 5 ; 25转化成二进制为11001，即:
   $$\begin{array}{rl}{8}^{25}& =8^{(1\ast 2^{16})}\ast 8^{(1\ast 2^8)}\ast 8^{(0\ast 2^4)}\ast 8^{(0\ast 2^2)}\ast 8^{(1\ast 2^0)}\\ & =8^{16}\ast 8^8\ast 8^0\ast 8^0\ast 8^1\\ & =8^1\ast 8^0\ast 8^0\ast 8^8\ast 8^{16}\end{array}$$

所以：
$$\begin{array}{rl}{8}^{25}mod5& =(8^1\ast 8^0\ast 8^0\ast 8^8\ast 8^{16})mod5\end{array}$$
程序逻辑实现：
以指数为25时11001为例：

循环	权重	赋值		取余	二进制值	说明
1	1	W= a % c	W=a	result = (result * W) % c;	1	该位值为1，所以将当前权重值保存到result中
2	2	W= (W* W) % c	W=$a^2$	*	0	为了计算高阶的值，继续计算权重 该位值为0，result不需要这个值
3	4	W= (W* W) % c	W=$a^4$	*	0	为了计算高阶的值，继续计算权重 该位值为0，result不需要这个值
4	8	W= (W * W) % c	W=$a^8$	result = (result * W) % c	1	为了计算高阶的值，继续计算权重 该位值为1，所以将当前权重值保存到result中
5	16	W= (W * W) % c	W=$a^{16}$	result = (result * W) % c	1	为了计算高阶的值，继续计算权重 该位值为1，所以将当前权重值保存到result中

指数=1+2+8+16，相对a来说，就是result=$a^1\ast a^2\ast a^8\ast a^{16}modc$

根据上述的公式可以推导出：
$$\begin{array}{rl}设：result& =8^{1}mod5=8mod5=3\\ 8^{2}mod5等于result& =result\ast resultmod5;此时result就等于8^{2}mod5=4\\ 8^{4}mod5等于result& =result\ast resultmod5;此时result就等于8^{4}mod5=1\\ 8^{8}mod5等于result& =result\ast resultmod5;此时result就等于8^{8}mod5=1\\ 8^{16}mod5等于result& =result\ast resultmod5;此时result就等于8^{16}mod5=1\end{array}$$
$8^{25}mod5$

循环	值	权重	赋值	权重取余结果	取余	说明
1	1	1	W= 8 % 5	W=a	result = (result * 8) % 5;	8%5 = 3
2	0	2	W= (W * W) % c	W=$8^2$ mod 3 = 4	*
3	0	4	W= (W * W) % c	W=$8^4$ mod 3 = 1	*
4	1	8	W= (W * W) % c	W=$8^8$ mod 3 = 1	result = (result * W) % c	3 * 1 % 5 = 3
5	1	16	W= (W * W) % c	W=$8^{16}$ mod 3 = 1	result = (result * W) % c	3 * 1 % 5 = 3

所以最终结果$8^{25}mod5=3$

算法实现

这个取模数学公式证明了， a的任意次幂的模数，运算，可以通过先求模，然后再乘以其它的数，再次取模，结果是一致的
这段代码，写的是A*B的积取模

typedef unsigned long long ull;
int a_b_mod_c(int a, ull b, int c)
{
	int result = 1;
	int weight = a % c;		// 这个位置的权重是1，所以是a^1次方
	if(b==0) return 1 % c;	// 指数为0时，任何数的0次方都为1，可以直接得出结果。
	if(b & 0x1==1) result = weight % c;	// 因为这个位置的值为1，将引用weight到result.
	b >>= 1;	// B的第1位的权重就是a,已经处理完成，就右移一位。
	while(b)
	{
		weight = ((weight % c) * (weight % c)) % c;	 // 求指数2的N次方的余数
		if(b & 0x1==1) result = (result * weight) % c;	// 该位的值为1，则把该位对应的权重也计算到最终结果来。
		b >>= 1;
	}
	
	return result;
}
//上面的代码可以简化一下
int a_b_mod_c(int a, ull b, int c)
{
	int result = 1;
	int weight = a % c;
	while(b)
	{
		if(b & 0x1==1) result = (result * weight) % c;	// 该位的值为1，则把该位对应的权重也计算到最终结果来。
		b >>= 1;
		weight = ((weight % c) * (weight % c)) % c;	 // 求指数2的N次方的余数
	}
	
	return result;
}

下面用更巧妙的方法实现，不过比较难理解。

int a_b_Mod_c1(int a, int b, int c)
{
    int digit[32];
    int i, k, resualt = 1;
    i = 0;
    while(b)
    {
        digit[i++] = b&0x00000001;
        b >>= 1;
    }
    
    for(k = i-1; k >= 0; k--)
    {
        resualt = (resualt * resualt) % c;
        if(digit[k] == 1) resualt = (resualt * a) % c;
    }
    return resualt;
}

下面的这个代码，效率就比较低了。

int a_b_Mod_c2(int a, int b, int c)
{
    int i, result = 1;
    //参数非法较验就不写了
    if(b<0 || c<0 || a<0) return -1;
    for(i = 0; i < b; i++) result = (result * a) % c;
    return result % c;
}

可以看到高效的幂取余运算基本就是O(1)的常量级的