突然发现之前学的算法有很多已经只是耳熟了,所以想要复习复习,水平有限,有错的还望指正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为质数
证明: 是欧拉定理的一种特殊情况,可以直接套欧拉定理的证明,不再称述
威尔逊定理
持续更新