快速幂算法

1.什么是快速幂

快速幂算法能帮我们算出指数非常大的幂，传统的求幂算法之所以时间复杂度非常高（为O(指数n)），就是因为当指数n非常大的时候，需要执行的循环操作次数也非常大。所以我们快速幂算法的核心思想就是每一步都把指数分成两半，而相应的底数做平方运算。这样不仅能把非常大的指数给不断变小，所需要执行的循环次数也变小，而最后表示的结果却一直不会变。

1.取模运算法则

1. (a + b) % p = (a % p + b % p) % p （1）

2. (a - b) % p = (a % p - b % p ) % p （2）

3. (a * b) % p = (a % p * b % p) % p （3）

2.具体思想

3^10=3*3*3*3*3*3*3*3*3*3

//尽量想办法把指数变小来，这里的指数为10

3^10=(3*3)*(3*3)*(3*3)*(3*3)*(3*3)

3^10=(3*3)^5

3^10=9^5

//此时指数由10缩减一半变成了5，而底数变成了原来的平方，求3^10原本需要执行10次循环操作，求9^5却只需要执行5次循环操作，但是3^10却等于9^5,我们用一次（底数做平方操作）的操作减少了原本一半的循环量，特别是在幂特别大的时候效果非常好，例如2^10000=4^5000,底数只是做了一个小小的平方操作，而指数就从10000变成了5000，减少了5000次的循环操作。

//现在我们的问题是如何把指数5变成原来的一半，5是一个奇数，5的一半是2.5，但是我们知道，指数不能为小数，因此我们不能这么简单粗暴的直接执行5/2，然而，这里还有另一种方法能表示9^5

9^5=（9^4）*（9^1）

//此时我们抽出了一个底数的一次方，这里即为9^1，这个9^1我们先单独移出来,剩下的9^4又能够在执行“缩指数”操作了，把指数缩小一半，底数执行平方操作

9^5=（81^2）*(9^1)

//把指数缩小一半，底数执行平方操作

9^5=（6561^1）*(9^1)

//此时，我们发现指数又变成了一个奇数1，按照上面对指数为奇数的操作方法，应该抽出了一个底数的一次方，这里即为6561^1，这个6561^1我们先单独移出来，但是此时指数却变成了0，也就意味着我们无法再进行“缩指数”操作了。

9^5=（6561^0）*(9^1)*(6561^1)=1*(9^1)*(6561^1)=(9^1)*(6561^1)=9*6561=59049

我们能够发现，最后的结果是9*6561，而9是怎么产生的？是不是当指数为奇数5时，此时底数为9。那6561又是怎么产生的呢？是不是当指数为奇数1时，此时的底数为6561。所以我们能发现一个规律：最后求出的幂结果实际上就是在变化过程中所有当指数为奇数时底数的乘积。

3.代码实现

#include<bits/stdc++.h>
using namespace std;
int main(){
	long long a,b,p,c,d;
	cin>>a>>b>>p;  //p是要取模的数
	c=a;d=b;
	long long sum=1;
	while(b>0){
		if(b%2==0){ //如果指数为偶数，指数减半
			b/=2;   
			a=a*a%p;  //底数变为原来的平方
   //如果写成a*=a%p，可能出现计算错误，因为运算级不同，会先算a%p
		}
		else{
			b--; //为偶数指数减一
			sum=sum*a%p; //用一个变量存入分离出的底数
			b/=2;
			a=a*a%p;
		}
	}
	cout<<c<<"^"<<d<<" mod "<<p<<"="<<sum;
	
}

还可以再简洁一点

int pu(int a, int b, int p){ 
    int ans = 1;
    while(b){
        if(b & 1)ans =(ans*a)%p;
        b >>= 1;
        a = (a*a) % p;
    }
    return ans;
}

和位运算结合的话，速度会更快