突然发现之前学的算法有很多已经只是耳熟了，所以想要复习复习，水平有限，有错的还望指正Q^Q
快速幂
二进制快速幂
当我们算2n时，有什么方法呢，首先最先想到的是我们可以直接暴力，一个for循环直接从1不断乘2，最后得到答案
int a=1,b=2;
for(int i=0;i<n;i++){
a*=b;
}
不过如果n变大了怎么办，如果n达到1e9的规模，那就不能在规定的时间算出来了，此时快速幂的作用就来了。
快速幂顾名思义就是幂运算非常快，我们可以将2n的幂也就是n用二进制分割出来，假如n为27，其二进制为11011，我们将其分为1，2 ，8，16，也就是将231分割为21 * 22 *2 8 * 216，哦~，是不是有一些规律，因为我们用了二进制划分，所以每个幂都是前面幂的2m次倍，也就是说，我们可以从前项递归出来后项的值，先上代码，pow(a,b)为计算ab的值
int pow(int a,int b){
int ans=1;
while(b){
if(b&1) ans*=a;//b&1用来判断b的最后一位是否为1
b>>=1;//左移一位
a*=a;
}
return ans;
}
我们将a设为2，b为27，也就是计算227的值，如果b&1值为1，就说明此时我们的a在我们分割的数中存在，就将其乘在我们的ans中，比如一开始b为27，27&1值为1，也就是第一位有值，此时的a对应着2，也就是21，乘到ans中，之后b往左位移一位，也就是现在判断第二位是否有值，并且此时的a变成了原来的平方倍，也就是22，也存在，将其乘在ans中，之后b继续左移，也就是判断第三位是否有值，此时无值，就不再乘到ans中，但是我们的a依然要变成原来的平方，也就是24，以此类推，换句话说，我们就是判断27的二进制11011，对应的1，2，4，8，16是否存在(1为存在，0为不存在)，如果x存在，就将2x，乘到ans中，最后就可以得到答案227了。算法复杂度由于b每次除2，所以最后时间和logn成正比，也就是O(logn)。
十进制快速幂
刚刚介绍的快速幂中我们利用了二进制，当然，我们也可以利用别的进制，不过速度并不会有质的提升了，如果计算nm，那么二进制快速幂就是log2m、十进制快速幂就是log10m，log2m / log10m = logcm / logc2 / logcm / logc10 = logc10 / logc2 = log210 ，也就是10进制快速幂比2进制快速幂快log210，但是由于其常数大，导致最后反而并没有更快，那么我们的十进制的快速幂就没用了吗，当然不是，接下来介绍一下十进制快速幂
当我们输入的数字超过long long时怎么办，我们只能用字符串读入了(自带大数运算的语言的选手不需要考虑这些Q^Q，Java大数真香)，此时我们再做除2的操作就太麻烦了(不过如果题目没有要求对一个小于int范围的数取余，那操作的复杂度并不会变小)，我们需要改变整个字符串，我们是否可以将范围限制到一个字符，此时，我们就可以用10进制了，因为数字是用10进制输入的(别的进制输入的数同理)，所以我们将其按照10进制分割，比如还是计算227，这次分割成220 * 27，上代码
long long pow(long long a,string b){
long long ans=1;
for(int i=b.length()-1;i>=0;i--){
for(int j=0;j<b[i]-'0';j++){
ans*=a;
}
long long d=a;
for(int j=1;j<10;j++){
a*=d;
}
}
return ans;
}
如此一来，快速幂大数的操作就方便了许多。
矩阵快速幂
既然提到了快速幂，那就不得不说矩阵快速幂，最经典的我觉得莫过于找斐波那契数列，不过目测矩阵快速幂依然不是斐波那契数列最快的求法，以后学学看看能不能来填个坑，这里先介绍矩阵快速幂
矩阵快速幂利用的是递推矩阵，我们通过计算斐波那契数列来得到计算方法，设Fn为斐波那契数列的第n项，设下列式子，其中A为一个矩阵
那我们只要得到矩阵A的值，就得到了他的递推式，这里就需要一些线性代数的知识了，我们通过将Fn+Fn-1的值，也就是Fn+1的值放在Fn的位置，并将Fn放在Fn-1的位置，我们就可以得到等式左边的式子，那么我们的A就可以出来了，因为A是左乘，所以会改变右边矩阵的行，我们先写出矩阵A的值
我们第一行为1 1，也就是把右边矩阵的第一行和第二行相加，第二行为1 0，也就是只要右边矩阵第一行的值，正好符合我们刚刚的推理，递推矩阵A找出来了，那么我们就可以通过F0和F1的值得到Fn和Fn+1的值了
哦吼，出现了一个An，我们刚刚的快速幂就不是用来求他的吗，没错，矩阵快速幂的快速幂就是体现在这里，理论说完了，上代码
const int MAX=3;
int ans[MAX]={0,1,0};
int a[MAX][MAX]={{0,0,0},{0,1,1},{0,1,0}};
void init(){
ans[1]=1;
ans[0]=ans[2]=0;
a[1][1]=a[1][2]=1;
a[2][1]=1,a[2][2]=0;
}
void multiAA(){
int c[MAX][MAX];
for(int i=1;i<MAX;i++){
for(int j=1;j<MAX;j++){
c[i][j]=0;
for(int k=1;k<MAX;k++){
c[i][j]+=a[i][k]*a[k][j];
}
}
}
for(int i=1;i<MAX;i++){
for(int j=1;j<MAX;j++){
a[i][j]=c[i][j];
}
}
}
void multiAAns(){
int c[MAX];
for(int i=1;i<MAX;i++){
c[i]=0;
for(int j=1;j<MAX;j++){
c[i]+=a[i][j]*ans[j];
}
}
for(int i=1;i<MAX;i++){
ans[i]=c[i];
}
}
void pow(long long b){
while(b){
if(b&1) multiAAns();
b>>=1;
multiAA();
}
}
用了全局变量，代码写的比较丑Q^Q，如果斐波那契数列Fn从1开始，为1 1 2 3 5……这样我们输入的是n，运算完后ans[1]就是Fn，算法复杂度为O(m3logn) ，其中m是矩阵的行列数，n为幂，矩阵的乘法可以优化到O(m2.81)，这里也先挖个坑以后来填矩阵乘法的优化(不过矩阵这么小，没什么意义，优化的算法常数比较大，小矩阵反而速度会慢)。
质数
来自百度百科的定义：质数是指在大于1的自然数中，除了1和它本身以外不再有其他因数的自然数。接下来介绍找质数的方法。
暴力法
最容易想到的暴力方法，暴力搜2到n-1，如果n可以整除他们，就证明n是个合数，算法复杂度为O(n)
#include<cstdio>
int main(){
int n;
scanf("%d",&n);
for(int i=2;i<n;i++){
if(n%i==0){
printf("合数！");
return 0;
}
}
printf("质数！");
return 0;
}
暴力法的改进
我们尝试对暴力进行改进，如果m是n的因子，那么n/m也一定是n的因子，所以我们需要查找的范围到m=n/m时就好了(m的范围为[2,n/m])，因为大于n/m的数如果是n的因子，那么一定有小于m的数是n的因子，也就是在m=n/m之前我们就会找到n的非1和n的因子，换句话说，我们只用从2找到sqrt(n)就好了，判断他们是否是n的因子，如果都不是，那么n一定为质数，算法复杂度为O(sqrt(n))。
#include<cstdio>
int main(){
int n;
scanf("%d",&n);
for(int m=2;m*m<=n;m++){
if(n%m==0){
printf("合数！");
return 0;
}
}
printf("质数！");
return 0;
}
埃氏筛法
如果只是查询一个数字是否是质数，那么O(sqrt(n))的时间复杂度已经够用了，但是如果是要找1到n的全部质数呢，那复杂度就要到O(n * sqrt(n))，如果n到1e6的大小，一般就会被卡了，我们就要寻找更快的方法了。
埃氏筛法的核心就是用质数筛它的倍数，比如要筛1到20的倍数，那么从2开始筛
第一轮(筛2的倍数)：2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
第二轮(筛3的倍数)：2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
下面就到该筛5的倍数了，但是由于5的平方大于20，所以其实我们此时已经把所有合数筛完了，换句话说，5的倍数只有5 * 1，5 * 2，5 * 3，5 * 4的值在范围内，但是当我们筛2，3的倍数的时候，已经把这些数筛过了，所以不用再次筛了，而内层循环之所以从i * i开始，是因为同样的道理，i * i-1，i * i-2这些数，在筛i-1的倍数和i-2的倍数时已经筛过了，算法的复杂度可以到O(nloglogn)，但是不会证Q^Q，上代码。
#include<cstdio>
const int MAX=1e6+5;
int isprime[MAX];
void solve(int n){
for(int i=2;i<=n;i++){ //初始化
isprime[i]=1;
}
for(int i=2;i*i<=n;i++){ //埃氏筛法
if(isprime[i]){
for(int j=i*i;j<=n;j+=i){
isprime[j]=0;
}
}
}
}
int main(){
int n;
scanf("%d",&n);
solve(n);
for(int i=0;i<=n;i++){
if(isprime[i]){
printf("%d ",i);
}
}
}
欧拉筛
参考自这篇博客传送门
埃氏筛法为什么会比O(n)慢呢，就是因为一个合数可能会被筛选多次，比如12，会被2筛，也会被3筛，我们可以想办法让一个数只被筛一次吗，此时欧拉筛就出现了，因为每个数只被筛了一次，所以复杂度可以到非常好的O(n)，那么如何让一个数只被筛一次，我们尝试只让他的最小质因子筛掉他，先上代码。
#include<cstdio>
const int MAX=1e6+5;
int isprime[MAX]; //存下标为i的数是否为质数
int prime[MAX]; //存所有质数
int primen; //存质数的数量
void solve(int n){
for(int i=2;i<=n;i++){ //初始化
isprime[i]=1;
}
for(int i=2;i<=n;i++){ //欧拉筛
if(isprime[i]){
prime[primen++]=i;
}
for(int j=0;j<primen;j++){
isprime[i*prime[j]]=0;
if(i%prime[j]==0){
break;
}
}
}
}
int main(){
int n;
scanf("%d",&n);
solve(n);
for(int i=0;i<=n;i++){
if(isprime[i]){
printf("%d ",i);
}
}
}
这里欧拉筛中的i是倍数，每次将prime[j]的i倍筛出来，如果prime[j]能整除i，就证明prime[j+1] * i，prime[j+2] * i…这些数也是prime[j]的倍数，因为此时i是prime[j]的倍数。我们的目的是将每个数通过最小质因数筛掉，所以prime[j+1] * i，prime[j+2] * i…这些数就应该交给prime[j]筛掉。比如此时的i是4，4 * 2=8，8被筛掉，如果此时不break，那么还会计算4 * 3=12，12被筛掉，但是12的最小值质因数应该是2，当i等于6时，12还会被筛掉，就浪费时间来重复筛了，所以当检查到4是2的倍数时，就要跳出循环。
欧几里得算法
欧几里得算法也就是辗转相除法，gcd(a,b)既是a的因子，又是b的因子，a%b=a-kb，因为gcd(a,b)是a和b的因子，所以也是a-kb的因子，因为a=c gcd(a,b)，b=d gcd(a,b)，a%b=a-kb=c gcd(a,b)-kd gcd(a,b)=(c-kd) gcd(a,b)，所以gcd(a,b)=gcd(b,a%b)，我们发现刚刚的推论是正确的前提是a>=b，那么如果a<b呢，我们代入公式gcd(a,b)=gcd(b,a%b)=gcd(b,a)，也就是a和b的顺序直接反过来了，此时b>a，正好符合条件，上代码。
int gcd(int a,int b){
return b?gcd(b,a%b):a;
}
算法的复杂度为O(log(a))，因为a大概每次都要比之前小2倍多。
扩展欧几里得算法
根据贝祖定理，一定存在ax+by=gcd(a,b)，那么我们怎么找整数x和y呢，原理如下
a * x1 + b * y1=gcd(a,b)=gcd(b,a%b)=b * x2 + a % b * y2
因为a % b * y2=( a - a / b * b ) * y2=a * y2 - a / b * b * y2
所以原式也就为b * x2 + a * y2 - a / b * b * y2 = a * y2 + b * ( x2 - a / b * y2 )
也就是x1=y2，y1=x2-a/b*y2，于是递推式就出来了，那么终止条件是什么呢，当b=0时，也就是ax=gcd(a,b)时，递归终止，此时a的值就是gcd(a,b)，所以终止时x=1，y=0，上代码。
int exgcd(int a,int b,int &x,int &y){
if(b==0){
x=1;
y=0;
return a;
}
int g=gcd(b,a%b,x,y);
int keep=x; //推出来递归之前的值
x=y;
y=keep-a/b*y;
return g;
}
类欧几里得算法
留个坑，还没学会
数论四大定理
欧拉定理
公式 aφ(n)≡1mod(n) 其中a与n互质，φ(n)为小于n与n互质的数的数量
证明: 定义一个集合，其中的数皆与n互质{b1 , b2 , b3 , …… , bφ(n)}
将集合每个数乘与a，得到一个新的集合{ab1 , ab2 , ab3 , …… , abφ(n)}
这两个集合皆满足任意两个数不模n同余，并且皆和n互质，百度百科已经将这两个情况证明的很清楚了，这里不再陈述。
所以 b1 * b2 * b3 * …… * bφ(n) ≡ ab1 * ab2 * ab3 * …… * abφ(n) mod(n)
所以 1 ≡ aφ(n)mod(n)
费马小定理
公式 ap-1≡1(mod p) 其中p为质数
证明: 是欧拉定理的一种特殊情况，可以直接套欧拉定理的证明，不再称述
威尔逊定理
持续更新
1317
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
