快速幂

这里介绍的是求a^b的运算。

常规思路：b个a相乘。

int pow(int a, int b){
	int ans = 1;
	for(int i = 1; i <= b; i ++){
		ans *= a;
	}
	return ans;
} 

但是当b很大时，复杂度很高，所以可以通过分奇偶来讨论。

当b是奇数时， a^b = a ^ (b/2) * a^(b/2) * a；

当b是偶数时，a^b = a ^ (b/2) * a^ (b/2)；

写法一：

int pow(int a, int n){// 调用了这个函数， 递归 
	if(n == 0){
		return 1;
	}
	if(n == 1){
		return a;
	}
	
    double ret =  pow(a, n /2); // pow(a, n >> 1)
	ret *= ret;
    if(n & 0x1){// n % 2 == 1
    	ret *= a;
	}
	return ret;
} 

写法二：

int pow(int a, int n){// 非递归 a^n/2 * a^n/2 (* a)?根据是否是奇偶？ 
	int ans = 1;
	while(n > 0){
		if(n % 2 == 1){
			ans *= a;
		}
		 n /= 2;
		 a *= a;
	}
	return ans;
} 

此外你可以结合位运算，例如2^10 = 2^(1010)，即将10写成二进制，下面就可一用1010的每一位&1,然后进行运算，注意移位。参考代码如下：

int pow(int a, int b){
	int ans = 1;
	while(b > 0){
		if(b & 1){ // 同为1时才需要做 
			ans *= a;
		}
		b >>= 1;
		a *= a;
	}
	return ans;
}

过程就是：a = 2 * 2 = 4；ans = 1 * 4 = 4， a = 4 * 4 = 16；a = 16 * 16 = 256； ans = 4 * 256 = 1024; ---- 输出ans。

很显然所用的时间要简单的多。

这个一般是结合快速幂的取余运算，形如a^b%1000。此时有一个结论：积的取余 = 取余后的积再取余。也就是说是某个因子取余之后再相乘再取余，余数保持不变。

那为什么要这么做呢？显然，a^b的结果计算，很容易就超过了int类型的存储界限。所以在计算过程中就对他取余不会导致越界，使得结果错误。

例题：求root(N, k)

题目描述：  N<k时，root(N,k) = N，否则，root(N,k) = root(N',k)。N'为N的k进制表示的各位数字之和。输入x,y,k，输出root(x^y,k)的值 (这里^为乘方，不是异或)，2=<k<=16，0<x,y<2000000000，有一半的测试点里 x^y 会溢出int的范围(>=2000000000) 。

输入描述： 每组测试数据包括一行，x(0<x<2000000000), y(0<y<2000000000), k(2<=k<=16)。

当然这里数学推导：
N=a0+a1*k+a2*k^2+……+an*k^n;
N'=a0+a1+a2+……+an;
N-N'=a1*(k-1)+a2*(k^2-1)+……+an*(k^n-1);
        提取(k-1)有: (N-N')%(K-1)=0;
        继续递推下去有：(N-N')%(k-1) =0；
                                    (N'-N'')%(k-1)=0;
                                      ……
                                      (N(r-1)-N(r))%(k-1)=0；
        相加有：(N-N(r))%(k-1)=0,N(r)是我们要求的结果，故有N(r) = N % (k-1);
        如果 N(r)==0 ,则 N(r) = k-1;

ac的代码（仅供参考）：

#include<iostream>
#include<cstdio> 
using namespace std;
long long root(long long base, long long exponent, long long k){
	long long ret = 1;
	base = base % k;
	while(exponent > 0){
		if(exponent % 2 == 1){
			ret = (base * ret) % k;
		}
		exponent >>= 1;
		base = (base * base) % k;
	}
	return ret;
} 
int main(){
	long long x, y, k, tmp;
	while(cin >> x >> y >> k){
		tmp =  root(x, y, k - 1);
		if(tmp == 0){
			tmp = k - 1;
		}
		cout << tmp << endl;
	}    
        return 0;
}

以上就是这篇的主要内容。欢迎提出您宝贵的意见，谢谢！