最近在牛客第一次碰到有关快速幂的知识，在此记录加深理解一下。大佬勿进，我怕《《 》》

快速取幂的用途

在一些竞赛中，可能会遇到指数型的数据取模问题，这个时候直接用int或者long long 储存，就非常有可能超出计算机整数的存取范围(哈哈，一般都会超，毕竟是竞赛！！！)，从而数据出错，所以我们就引出今天的主角色 快速幂取模。这种方法在时间和空间都做了尽可能的优化，非常好用哦！

快速幂取模的思路分析

基本理论是离散数学的知识*(数学很重要!）*
有一个引理我们需要清楚的：积的取余等于取余的积的取余。
公式：(ab)%c = (a%c)(b%c)%c
核心思想是将大数幂运算拆解成相应的乘法运算，利用上述式子，始终将我们的运算的数据量控制在c的范围下。

以求a的b次方来介绍
把b转换成二进制数。
例如
11的二进制是1011
对二进制的位运算，在此就不赘述，有问题的同学请自行百度，这里我们需要用到“&”与“>>”运算符。

先来一段具体代码，由代码来讲解

ll binaryPow(ll num, ll k) 
{
 ll ans = 1;
 while(k>0)
 {
  if(k&1)
   ans = ans*num%mod;//如果k的二进制位不是0，那么就会进行该步
  num = num*num%mod;//不断加倍
  k >>=1; //相当于每次除以2，用二进制看，不断的遍历k的二进制位
 }
 return ans;
}

在上面的代码中，k&1意思就是取k的二进制的最末位，11的二进制数为1011，第一次循环，取的是最右边的1，以此类推。k>>=1意思就是k右移一位，删去最低位置。
接下来我来说说while循环中的原理。
以num^11为例子，k = 11
k 的二进制 1011。
我们要理解num = num * num；这一步的作用。
哎嗨，快速幂就讲解完了。希望大家可以共同进步。另外注明一点，代码%mod也是为了防止溢出，这是从下面一道训练题想出来的。
下面贴出来一道例题。
题目链接
https://ac.nowcoder.com/acm/contest/3003/G

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cmath>
using namespace std;
typedef long long ll;
const int maxn = 200005;
const int mod = 1e9+10;
typedef long long ll;
ll binaryPow(ll num, ll k) 
{
 ll ans = 1;
 while(k>0)
 {
  if(k&1)
   ans = ans*num%mod;
  num = num*num%mod;
  k >>=1; 
 }
 return ans;
}
 
int main()
{
 ios::sync_with_stdio(false);
 int t;
 cin >> t;
 while (t--)
 {
  long long a, b, c, d, e, f, g;
  cin >> a >> b >> c >> d >> e >> f >> g;
  int sum = 0;
  int m = 1e9 + 7;
  if (binaryPow(a,d)+binaryPow(b,e)+binaryPow(c,f) == g)
  {
   cout << "Yes" << endl;
  }
  else
  {
   cout << "No" << endl;
  }
 }
 return 0;
}

就这样吧，溜走。

        矩阵的快速幂是用来高效地计算矩阵的高次方的。将朴素的o(n)的时间复杂度，降到log（n）。这里先对原理（主要运用了矩阵乘法的结合律）做下简单形象的介绍：一般一个矩阵的n次方，我们会通过连乘n-1次来得到它的n次幂。

        但做下简单的改进就能减少连乘的次数，方法如下：

       把n个矩阵进行两两分组，比如：A*A*A*A*A*A  =>  (A*A)*(A*A)*(A*A),这样就只需要计算一次A*A，然后将结果(A*A)连乘自己两次就能得到A^6，即(A*A)^3=A^6。算一下发现这次一共乘了3次，少于原来的3次。其实大家还可以取A^3作为一个基本单位。原理都一样：利用矩阵乘法的结合律，来减少重复计算的次数。

       以上都是取一个具体的数来作为最小单位的长度，这样做虽然能够改进效率，但缺陷也是很明显的，取个极限的例子（可能有点不恰当，但基本能说明问题），当n无穷大的时候，你现在所取的长度其实和1没什么区别。所以就需要我们找到一种与n增长速度”相适应“的”单位长度“，那这个长度到底怎么去取呢？？？这点是我们要思考的问题。

      有了以上的知识，我们现在再来看看，到底怎么迅速地求得矩阵的N次幂。

      既然要减少重复计算，那么就要充分利用现有的计算结果咯！~怎么充分利用计算结果呢？？？这里考虑二分的思想。大家首先要认识到这一点：任何一个整数N，都能用二进制来表示。。这点大家都应该知道，但其中的内涵真的很深很深（这点笔者感触很深，在文章的最后，我将谈谈我对的感想）！！

        计算机处理的是离散的信息，都是以0,1来作为信号的处理的。可想而知二进制在计算机上起着举足轻重的地位。它能将模拟信号转化成数字信号，将原来连续的实际模型，用一个离散的算法模型来解决。  好了，扯得有点多了，不过相信这写对下面的讲解还是有用的。

       回头看看矩阵的快速幂问题，我们是不是也能把它离散化呢？比如A^19  =>  （A^16）*（A^2）*（A^1），显然采取这样的方式计算时因子数将是log(n)级别的(原来的因子数是n)，不仅这样，因子间也是存在某种联系的，比如A^4能通过(A^2)*(A^2)得到，A^8又能通过(A^4)*(A^4)得到，这点也充分利用了现有的结果作为有利条件。下面举个例子进行说明：

       现在要求A^156,而156(10)=10011100(2) ，也就有A^156=>(A^4)*(A^8)*(A^16)*(A^128)  考虑到因子间的联系，我们从二进制10011100中的最右端开始计算到最左端。细节就说到这，下面给核心代码：

if(N&1)  
       res=res*A;     //二进制位为1时执行此步  
 n>>=1;  
 A=A*A;     //实质上这步只是不断地使二进制位从右向左移动，实现的是使res乘的A值等于2^(对应位+1)  

        里面的乘号，是矩阵乘的运算，res是结果矩阵。

      第3行代码每进行一次，二进制数就少了最后面的一个1。二进制数有多少个1就第3行代码就执行多少次。

      即每次执行第3行代码结果为:

res* a^4 * a^8  *  a^16  *a^128 

      现在我就说下我对二进制的感想吧：

      我们在做很多”连续“的问题的时候都会用到二进制将他们离散简化

Description

Fermat's theorem states that for any prime number p and for any integer a > 1, ap = a (mod p). That is, if we raise a to the pth power and divide by p, the remainder is a. Some (but not very many) non-prime values of p, known as base-a pseudoprimes, have this property for some a. (And some, known as Carmichael Numbers, are base-a pseudoprimes for all a.)

Given 2 < p ≤ 1000000000 and 1 < a < p, determine whether or not p is a base-a pseudoprime.

Input

Input contains several test cases followed by a line containing "0 0". Each test case consists of a line containing p and a.

Output

For each test case, output "yes" if p is a base-a pseudoprime; otherwise output "no".

Sample Input

3 2
10 3
341 2
341 3
1105 2
1105 3
0 0

Sample Output

no
no
yes
no
yes
yes

#include<cstdio>
#define N 45000
struct st
{
	int a,b;
}s[N];
long quickpow(long n,long m,long mod)
{
	long ans=1,base=n;
	
	while(m)
	{
		if(m&1)
		  ans=((ans%mod)*(base%mod))%mod;
		base=((base%mod)*(base%mod))%mod;
		m>>=1;				
	}
	return ans;
}
int main()
{
	int t,n,i,h;
	long sum,m;
	scanf("%d",&t);
	while(t--)
	{
		sum=0;
		scanf("%ld",&m);
		scanf("%d",&h);
		for(i=0;i<h;i++)
		   scanf("%d%d",&s[i].a,&s[i].b);
		for(i=0;i<h;i++)
		   sum+=quickpow(s[i].a,s[i].b,m);
		sum%=m;
		printf("%ld\n",sum);
	}
	return 0;
}

(a+b+c+d+e)%x=(a%x+b%x+c%x+d%x+e%x)%x ;

2、(a*b*c*d*e)%x=(a%x*b%x*c%x*d%x*e%x)%x ;

十进数转成二进数

整数部分采用 "除2取余，逆序排列"法。

整数部分，把十进制转成二进制一直分解至商数为0。读余数从下读到上，即是二进制的整数部分数字。 小数部分，则用其乘2，取其整数部分的结果，再用计算后的小数部分依此重复计算，算到小数部分全为0为止，之后读所有计算后整数部分的数字，从上读到下。
将59 转成二进制：

整数部分：
59 ÷ 2 = 29 ... 1
29 ÷ 2 = 14 ... 1
14 ÷ 2 =  7 ... 0
 7 ÷ 2 =  3 ... 1
 3 ÷ 2 =  1 ... 1
 1 ÷ 2 =  0 ... 1

十进制的59转化二进制为111011

二进位转成十进位

方法：“按权展开求和”，该方法的具体步骤是先将二进制的数写成加权系数展开式，而后根据十进制的加法规则进行求和 [6] 。

【例】：

规律：个位上的数字的次数是0，十位上的数字的次数是1，…，依次递增，而十分位的数字的次数是-1，百分位上数字的次数是-2，…，依次递减。

二进制的1011对应十进制的11

使用位运算(&)代替取模运算(%)

位运算(&)效率要比取模运算(%)高很多，主要原因是位运算直接对内存数据进行操作，不需要转成十进制，因此处理速度非常快。

a % b == a & (b - 1)

前提：b 为 2^n

来源自 HashMap 中的 indexFor 方法：

static int indexFor(int h, int length) {
   return h & (length-1);//h%length
}

这个方法是使用哈希值对链表数组的长度取模，得到值所在的索引位置，里面使用位运算（&）代替普通的（%）运算。