快速幂 矩阵快速幂 + 斐波那契数

最新推荐文章于 2023-04-28 22:31:45 发布
最新推荐文章于 2023-04-28 22:31:45 发布
阅读量210 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fusu123456789/article/details/105897857
版权

相关博文：
添加链接描述
添加链接描述

相关题目：
poj3070（板子题）
解题思路：矩阵快速幂求斐波那契数列第n项，至于题目里说的去掉前导0，不用管本来直接int就不会打印出前导0（如果要加上前导0也很简单，printf("%d\n",b[0][1]）改成printf("%04d\n",b[0][1])即可）

接下来是我的ac代码：

#include<iostream>
#include<cstdio>
#include<cstring>
//#include<bits\stdc++.h>提交的时候要勾选g++提交

using namespace std;

int ans[2][2];
int a[2][2]={0},b[2][2]={0};
const int mod=10000;

//矩阵乘法
void matrix(int a[2][2],int b[2][2],int ans[2][2])
{
    int t[2][2]={0};
    for(int i=0;i<2;i++){
        for(int j=0;j<2;j++){
            for(int k=0;k<2;k++){
                t[i][j]=(t[i][j]+a[i][k]*b[k][j])%mod;
            }
        }
    }
    for(int i=0;i<2;i++){
        for(int j=0;j<2;j++){
            ans[i][j]=t[i][j];
        }
    }//本来用的是memcpy（ans，t，sizeof（ans））；但是用这个却没有结果，用循环反而有结果，没想明白，memcpy不是更高效吗？
}

//快速幂
void quick_pow(int n)
{
    while(n){
        if(n&1)matrix(a,b,b);//跟快速幂是一样的，相当于ans=（ans*x）%mod
        matrix(a,a,a);
        n=n>>1;
    }
}

int main()
{
    int n;
    while(~scanf("%d",&n)&&n!=-1){
        a[0][0]=a[0][1]=a[1][0]=1,a[1][1]=0;
        b[0][0]=b[1][1]=1,b[0][1]=b[1][0]=0;//创建单位矩阵，即[i][i]位均为1，其他位位0时为单位数组
        quick_pow(n);
        printf("%04d\n",b[0][1]);//根据矩阵乘法及斐波那契数列规律知道打印b[1][0]也是一样的，都代表Fn
    }
    return 0;
}

hdu3306
知识点：递推+矩阵构造，利用矩阵解斐波那契前n项和，膜拜大佬构造方法，请参考这篇文章
分析：An+1=xAn+yAn-1
Sn+1=Sn+An+1^2
=Sn+x^2 * An^2 +y^2 * An-1^ 2+2xyAnAn-1
An+1An=xAn^2 + yAn-1An
由这三个式子可以构造矩阵，右乘矩阵A见代码，左乘矩阵S={Sn,An^2, An-12,An*An-1}，初始化为{S1,A12 , A0^2 , A1*A0},右乘矩阵乘n-1次幂后可得结果Sn存在S[0]中
ac代码：

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>

using namespace std;

typedef long long ll;
const int mod=10007,N=4;
ll A[N][N],S[N];

void matrix1(ll a[][N],ll b[N])
{
    ll t[N]={0};
    for(int i=0;i<N;i++){
        for(int j=0;j<N;j++){
            t[i]+=a[i][j]*b[j];
        }
    }
    for(int i=0;i<N;i++)b[i]=t[i]%mod;
}

void matrix2(ll a[][N],ll b[][N])
{
    ll t[N][N]={0};
    for(int i=0;i<N;i++){
        for(int j=0;j<N;j++){
            for(int k=0;k<N;k++){
                t[i][j]+=a[i][k]*b[k][j]%mod;
            }
        }
    }
    for(int i=0;i<N;i++){
        for(int j=0;j<N;j++){
            a[i][j]=t[i][j]%mod;
        }
    }
}

void mat_pow(ll n)
{
    while(n){
        if(n&1)matrix1(A,S);
        matrix2(A,A);
        n>>=1;
    }
}

int main()
{
    ll n,x,y;
    while(cin>>n>>x>>y){
        A[0][0]=1,A[0][1]=A[1][1]=x*x%mod,A[0][2]=A[1][2]=y*y%mod;
        A[0][3]=A[1][3]=2*x*y%mod,A[1][0]=A[2][0]=A[2][2]=A[2][3]=A[3][0]=A[3][2]=0;
        A[2][1]=1,A[3][1]=x%mod,A[3][3]=y%mod;
        S[0]=2,S[1]=S[2]=S[3]=1;
        mat_pow(n-1);
        cout<<(S[0]%mod+mod)%mod<<endl;
    }
    return 0;
}

hdu3524 规律题（用高中数学知识构造通项公式，然后注意一下要用费马小定理求逆元）

/**先自己写程序模拟计算过程跑出结果，然后找规律
 * 打表如下
 * n对应的sum值从1开始分别为：2，2，3，4，7，12，23，44，87，172...
 * (ps:暴力模的话到n=12以后我就跑不出结果了，n=9包括之前的结果都没问题，之后
 * 的不行，这种方法慎用，不然结果都跑错了后面就不用推了，还是手算几组数据比较
 * 安全，但是手算好累啊我的天-_-)
 * 发现奇数项和偶数项规律递增，仔细观察
 * n   sum
 * 1    2
 * 3    3=2+2^0
 * 5    7=2+2^0+2^2
 * 7    23=2+2^0+2^2+2^4
 * 9    87=2+2^0+2^2+2^4+2^6
 * ...
 * 2    2
 * 4    4=2+2^1
 * 6    12=2+2^1+2^3
 * 8    44=2+2^1+2^3+2^5
 * 10   172=2+2^1+2^3+2^5+2^7
 * ...
 * 
 * 可以发现奇数项是：2+2^0+2^2+2^4+...(共有(n+1)/2这么多项数)
 * 同理发现偶数项是:2+2^1+2^3+2^5+2^7+...(共有n/2这么多项数)
 * 
 * 对奇数项：
 * a1=2 
 * a2-a1=2^0
 * a3-a2=2^2
 * a4-a3=2^4
 * ...
 * an-an-1=2^(2n-4)(n是该项在奇数项中的位置)
 * 构造奇数项通项公式为：an=2+(4^(n-1)-1)/3
 * 
 * 对偶数项：
 * a1=2
 * a2-a1=2^1
 * a3-a2=2^3
 * a4-a3=2^5
 * ...
 * an-an-1=2^(2*(n-1)-1)=2^(2n-3)
 * 构造偶数项通项公式为：an=2*(4^(n-1)/3+1)
 * 
 * 额，高中数学构造通项公式的知识点都有点忘了，，，真的是，，，
 * 我这是在写数学吧，果然还是数学强，哪里都用得到
*/

#include<iostream>
#include<cstring>
#include<cmath>

using namespace std;

typedef long long ll;

const int mod=10007;

ll quick_pow(ll x,ll y)
{
    ll ans=1;
    while(y){
        if(y&1)ans=(ans*x)%mod;
        x=(x*x)%mod;
        y>>=1;
    }
    return ans%mod;
}

const int inv=quick_pow(3,mod-2);

int main()
{
    ll n,t;
    cin>>t;
    for(int i=1;i<=t;i++){
        cin>>n;
        ll ans;
        if(n&1){
            n=(n+1)/2;
            ans=(2+(quick_pow(4,n-1)-1)*inv)%mod;//注意一定不能直接除以3，会wa，得运用费马小定理求出3的逆元以后转化成乘以3的逆元
        }else{
            n=n/2;
            ans=(2*((quick_pow(4,n-1)-1)*inv+1))%mod;
        }
        printf("Case #%d: %lld\n",i,ans%mod);
    }
    //system("pause");
    return 0;
}

acwing1303 斐波那契前n项和
思路：递推公式+矩阵构造
ac code：
20ms

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>

using namespace std;

typedef long long ll;
ll n,mod;
const int N=3;
ll A[N][N]={
    {2,0,-1},
    {1,0,0},
    {0,1,0},
};
ll S[N]={2,1,0};

void matrix1(ll a[][N],ll b[N])
{
    ll t[N]={0};
    for(int i=0;i<N;i++){
        for(int j=0;j<N;j++){
            t[i]+=a[i][j]*b[j]%mod;
        }
    }
    for(int i=0;i<N;i++)b[i]=t[i]%mod;
}

void matrix2(ll a[][N],ll b[][N])
{
    ll t[N][N]={0};
    for(int i=0;i<N;i++){
        for(int j=0;j<N;j++){
            for(int k=0;k<N;k++){
                t[i][j]+=a[i][k]*b[k][j]%mod;
            }
        }
    }
    for(int i=0;i<N;i++){
        for(int j=0;j<N;j++){
            a[i][j]=t[i][j]%mod;
        }
    }
}

void mat_pow(ll n)
{
    while(n){
        if(n&1)matrix1(A,S);
        matrix2(A,A);
        n>>=1;
    }
}

int main()
{
    cin>>n>>mod;
    mat_pow(n);
    cout<<(S[2]%mod+mod)%mod<<endl;
    return 0;
}

改结构体板子：
ac 17ms

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>

using namespace std;

typedef long long ll;
ll n,mod;
const int N=3;

struct res{
    ll a[N][N];
    ll b[N];
    res(){
        memset(a,0,sizeof(a));
        memset(b,0,sizeof(b));
    }
};

res matrix1(res A,res B)
{
    res T;
    for(int i=0;i<N;i++){
        for(int j=0;j<N;j++){
            T.b[i]+=A.a[i][j]*B.b[j]%mod;
        }
    }
    for(int i=0;i<N;i++)B.b[i]=T.b[i]%mod;
    return T;
}

res matrix2(res A,res B)
{
    res T;
    for(int i=0;i<N;i++){
        for(int j=0;j<N;j++){
            for(int k=0;k<N;k++){
                T.a[i][j]+=A.a[i][k]*B.a[k][j]%mod;
            }
        }
    }
    return T;
}

res mat_pow(ll n)
{
    res A,S;
    A.a[0][0]=2,A.a[0][1]=A.a[1][1]=A.a[1][2]=A.a[2][0]=A.a[2][2]=0;
    A.a[0][2]=-1,A.a[1][0]=A.a[2][1]=1;
    S.b[0]=2,S.b[1]=1,S.b[2]=0;
    while(n){
        if(n&1)S=matrix1(A,S);
        A=matrix2(A,A);
        n>>=1;
    }
    return S;
}

int main()
{
    cin>>n>>mod;
    res ans=mat_pow(n);
    cout<<(ans.b[2]%mod+mod)%mod<<endl;
    return 0;
}

awing1304 斐波那契+递推+矩阵快速幂
分析：Sn=F1+2F2+…+nFn
Sn=Sn-1+nFn
=Sn-1+n(Fn-1+Fn-2)
=Sn-1+(n-1)Fn-1+(n-2)Fn-2+Fn-1+2Fn-2
=Sn-1+Sn-1-Sn-2+Sn-2-Sn-3+Fn-1+2Fn-2
=2Sn-1-Sn-3+Fn-1+2Fn-2
由Sn=2Sn-1-Sn-3+Fn-1+2Fn-2构造构造矩阵A，A数值见代码，A={{2,0,-1,1,2},{1,0,0,0,0},{0,1,0,0,0},{0,0,0,1,1},{0,0,0,1,0}};S[N]={Sn-1,Sn-2,Sn-3,Fn-1,Fn-2}，因此A通过矩阵快速幂n次方后乘以S的初始矩阵{S2,S1,S0,F2,F1}以后的结果存入S，得S={Sn+2,Sn+1,Sn,Fn+2,Fn+1}，结果存在S[2]中，取出结果即可

ac：

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>

using namespace std;

typedef long long ll;
ll n,mod;
const int N=5;
ll A[N][N]={
    {2,0,-1,1,2},
    {1,0,0,0,0},
    {0,1,0,0,0},
    {0,0,0,1,1},
    {0,0,0,1,0}
};
ll S[N]={3,1,0,1,1};

void matrix1(ll a[][N],ll b[N])
{
    ll t[N]={0};
    for(int i=0;i<N;i++){
        for(int j=0;j<N;j++){
            t[i]+=a[i][j]*b[j]%mod;
        }
    }
    for(int i=0;i<N;i++)b[i]=t[i]%mod;
}

void matrix2(ll a[][N],ll b[][N])
{
    ll t[N][N]={0};
    for(int i=0;i<N;i++){
        for(int j=0;j<N;j++){
            for(int k=0;k<N;k++){
                t[i][j]+=a[i][k]*b[k][j]%mod;
            }
        }
    }
    for(int i=0;i<N;i++){
        for(int j=0;j<N;j++){
            a[i][j]=t[i][j]%mod;
        }
    }
}

void mat_pow(ll n)
{
    while(n){
        if(n&1)matrix1(A,S);
        matrix2(A,A);
        n>>=1;
    }
}

int main()
{
    cin>>n>>mod;
    mat_pow(n);
    cout<<(S[2]%mod+mod)%mod<<endl;
    return 0;
}

HAOI2015 矩阵DP
。。。
向量内积
本来以为就是直接矩阵乘法计算向量内积，没想到还要用转置矩阵，而且还要直接分出k=2和k=3两种情况来做，比较复杂。。。先放放（case：15.00%，代码见牛客账号）
hdu2817 快速幂+等比等差公式
题意：给出前三个数，发现他的规律，并打印第k个数的结果
分析：通过前三个数的规律可以知道这个序列的规律，因此，数列要么是等比，要么是等差，如果a1+a3=2a2，则为等差，否则等比，然后直接套用等差等比的通项公式即可求解，等比第k项求解时记得取模

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>

using namespace std;

typedef long long ll;

const int mod=200907;

ll quick_pow(ll x,ll y)
{
    ll ans=1;
    while(y){
        if(y&1)ans=(ans*x)%mod;
        x=(x*x)%mod;
        y>>=1;
    }
    return ans%mod;
}

int main()
{
    ll t,a,b,c,d,ans;
    scanf("%lld",&t);
    while(t--){
        scanf("%lld%lld%lld%lld",&a,&b,&c,&d);
        if((a+c)==(b+b)){
            ans=(a+(d-1)*(b-a))%mod;
        }else{
            b=(b/a)%mod;
            a%=mod;
            ans=a*quick_pow(b,d-1)%mod;
        }
        printf("%lld\n",ans);
    }
    return 0;
}

hdu1575 模板题

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>

using namespace std;

typedef long long ll;
const int mod=9973;
const int M=12;
int N;

struct res{
    int arr[M][M];
    res(){
        memset(arr,0,sizeof(arr));
    }
};

res matrix(res a,res b)
{
    res t;
    for(int i=0;i<N;i++){
        for(int j=0;j<N;j++){
            for(int k=0;k<N;k++){
                t.arr[i][j]=(t.arr[i][j]%mod+a.arr[i][k]*b.arr[k][j]%mod)%mod;
            }
        }
    }
    return t;
}

res mat_pow(res a,int n)
{
    res ans;
    for(int i=0;i<N;i++)ans.arr[i][i]=1;
    while(n){
        if(n&1)ans=matrix(ans,a);
        a=matrix(a,a);
        n>>=1;
    }
    return ans;
}

int main()
{
    int t;
    scanf("%d",&t);
    while(t--){
        int k;
        scanf("%d%d",&N,&k);
        res a;
        for(int i=0;i<N;i++){
            for(int j=0;j<N;j++){
                scanf("%d",&a.arr[i][j]);
            }
        }
        a=mat_pow(a,k);
        ll sum=0;
        for(int i=0;i<N;i++){
            sum+=a.arr[i][i]%mod;
        }
        printf("%lld\n",sum%mod);
    }
    return 0;
}

Matrix Multiplication
矩阵快速幂简单题

#include<iostream>
#include<cstdio>
#include<cstring>

using namespace std;

typedef long long ll;
const int N=30;
int A[N][N],B[N][N],t[N][N];

void matrix(int a[N][N],int b[N][N],int n1,int m2,int m)
{
    for(int i=0;i<n1;i++){
        for(int j=0;j<m2;j++){
            for(int k=0;k<m;k++){
                t[i][j]+=a[i][k]*b[k][j];
            }
        }
    }
    for(int i=0;i<n1;i++){
        for(int j=0;j<m2;j++){
            printf("%d ",t[i][j]);
        }
        printf("\n");
    }
}

int main()
{
    int T;
    scanf("%d",&T);
    for(int kase=1;kase<=T;kase++){
        int n1,m1,n2,m2;
        scanf("%d%d%d%d",&n1,&m1,&n2,&m2);
        memset(t,0,sizeof(t));
        for(int i=0;i<n1;i++){
            for(int j=0;j<m1;j++){
                scanf("%d",&A[i][j]);
            }
        }
        for(int i=0;i<n2;i++){
            for(int j=0;j<m2;j++){
                scanf("%d",&B[i][j]);
            }
        }
        printf("Case %d:\n",kase);//注意一下，这个打印要等输入完成以后才可以进行，这种错误别再犯
        if(m1!=n2){printf("ERROR\n");continue;}
        matrix(A,B,n1,m2,m1);
    }
    return 0;
}

布置会场II
思路：举几个例子可以发现规律是斐波那契数，直接矩阵乘法打印斐波那契数就可以，简单题

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>

using namespace std;

typedef long long ll;
const int mod=1000000007;
const int N=2;
ll A[N][N],B[N];

void matrix1(ll a[][N],ll b[N])
{
    ll t[N]={0};
    for(int i=0;i<N;i++){
        for(int j=0;j<N;j++){
            t[i]+=a[i][j]*b[j]%mod;
        }
    }
    for(int i=0;i<N;i++)b[i]=t[i]%mod;
}

void matrix2(ll a[][N],ll b[][N])
{
    ll t[N][N]={0};
    for(int i=0;i<N;i++){
        for(int j=0;j<N;j++){
            for(int k=0;k<N;k++){
                t[i][j]+=a[i][k]*b[k][j]%mod;
            }
        }
    }
    for(int i=0;i<N;i++){
        for(int j=0;j<N;j++){
            a[i][j]=t[i][j]%mod;
        }
    }
}

void mat_pow(ll n)
{
    while(n){
        if(n&1)matrix1(A,B);
        matrix2(A,A);
        n>>=1;
    }
}

int main()
{
    ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
    int t;
    cin>>t;
    while(t--){
        ll n;
        cin>>n;
        A[0][0]=A[0][1]=A[1][0]=1,A[1][1]=0;
        B[0]=2,B[1]=1;
        mat_pow(n-1);
        cout<<B[1]%mod<<endl;
    }
    return 0;
}

递推
思路：由题目给出条件an=2*an-1+n^2可以构造左乘矩阵A，以及右乘矩阵B={an-1, n^2, n,1}，得答案矩阵{an,(n+1)^2,n+1,1}，并将B初始化为{a0,1,1,1}，对A求n次方后乘以B，返回B[0]即所求答案(主要还是递推构造矩阵，属于简单题）

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>

using namespace std;

typedef long long ll;
const int mod=1000000009;
const int N=4;
ll A[N][N],B[N];

void matrix1(ll a[][N],ll b[N])
{
    ll t[N]={0};
    for(int i=0;i<N;i++){
        for(int j=0;j<N;j++){
            t[i]+=a[i][j]*b[j]%mod;
        }
    }
    for(int i=0;i<N;i++)b[i]=t[i]%mod;
}

void matrix2(ll a[][N],ll b[][N])
{
    ll t[N][N]={0};
    for(int i=0;i<N;i++){
        for(int j=0;j<N;j++){
            for(int k=0;k<N;k++){
                t[i][j]+=a[i][k]*b[k][j]%mod;
            }
        }
    }
    for(int i=0;i<N;i++){
        for(int j=0;j<N;j++){
            a[i][j]=t[i][j]%mod;
        }
    }
}

void mat_pow(ll n)
{
    while(n){
        if(n&1)matrix1(A,B);
        matrix2(A,A);
        n>>=1;
    }
}

int main()
{
    ll n;
    while(~scanf("%lld",&n)){
        A[0][0]=A[1][2]=2,A[0][1]=A[1][1]=A[1][3]=A[2][2]=A[2][3]=A[3][3]=1;
        A[0][2]=A[0][3]=A[1][0]=A[2][0]=A[2][1]=A[3][0]=A[3][1]=A[3][2]=0;
        B[0]=0,B[1]=1,B[2]=1,B[3]=1;
        mat_pow(n);
        printf("%lld\n",B[0]%mod);
    }
    return 0;
}
岁余冬雨
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
矩阵快速幂求解斐波那契
04-13
矩阵快速幂 幂又称乘方。表示一个数字乘若干次的形式,如n个a相乘的幂为a^n ，或称a^n为a的n次幂。a称为幂的底数，n称为幂的指数。 快速幂的思路就是：设A为矩阵，求A的N次方，N很大。例如：A的9次方 A^9 = A*A*A...
矩阵快速幂 斐波那契数列
glorious_dream的博客
01-22 843
首先是矩阵乘法 在矩阵乘法中满足以下运算律： 1.(AB)C=a(BC) 2.(A+B)C=AC+BC 3.C(A+B)=CA+CB 在普通的乘法中，一个数乘1还是等于它本身，在矩阵乘法中也有这么一个“1”，它就是单位矩阵 不同于普通乘法中的单位1，对于不同矩阵他们的单位矩阵大小是不同的 对于n∗mn*mn∗m的矩阵，它的单位矩阵大小为m∗mm*mm∗m，对于m∗nm*nm∗n的矩阵，它的单位矩阵大小为n∗nn*nn∗n 也就是说单位矩阵都是正方形的，这是因为只有正方形的矩阵能保证结果和前.
矩阵快速幂&斐波那契数列
m0_59251000的博客
02-11 1673
矩阵快速幂
c++--求斐波拉切数列最快的方法（矩阵快速幂方法）O（n）=logn（详细）
m0_60447786的博客
01-28 1326
求斐波拉切数列常用方法： 递归法：O（n）=n*n for循环法：O(n)=n 矩阵快速幂法：O(n)=logn 先介绍数快速幂法 求一个数的n次方，如果n很大，比如： int n; int a; cin>>a; cin>>n; pow(a,n); //n>100000000 这时如果再用头文件#include<cmath>中的pow函数会非常慢，所以不可取。 如果用for循环方法，比如211，用for循环要计算11次，但是
斐波那契（矩阵快速幂）
correct
04-09 284
今天随便看了看矩阵的相关内容，顺势学习了一下矩阵构造和矩阵快速幂，然后又顺道写了这个入门题。 斐波那契数列，即FibFibFibn =Fib=Fib=Fibn-1+Fib+Fib+Fibn-2，就这么一个数列，显然可以直接地推求解，时间复杂度O(N)O(N)O(N)，似乎没什么问题。 然后就遇到了这个，nnn的取值范围最大是2×1092\times10^92×109的这么一个题，线性显然不能满足时...
CodeForces 185A Plant
qq_35567103的博客
08-12 434
http://codeforces.com/problemset/problem/185/APlantDwarfs have planted a very interesting plant, which is a triangle directed “upwards”. This plant has an amusing feature. After one year a triangle pla
【矩阵快速幂 | 斐波那契数列 | 矩阵加速】
Cauchy的博客
04-28 897
【代码】【矩阵快速幂 | 斐波那契数列 | 矩阵加速】
C++题解：矩阵快速幂 求 斐波那契数列
Keven_11的博客
08-18 1168
一般先构造最后表示答案的矩阵，比如这里我们构造一个 1×2 的矩阵里边填上最开始的两项[a1​,a2​] ，接下来我们考虑把它往后推到 [a2​,a3​] ，那么我们需要构造一个矩阵，让 [a1​,a2​] 乘这个矩阵得到 [a2​,a3​]。依次看后边矩阵的每一项，看它可以由前边矩阵里边的每一项怎么凑出来，会发现 a2​=a2​,a3​=a1​+a2​，所以构造一个 2×2 的矩阵 A=[0,1，1,1​] ，这样就可以按照矩阵乘法递推，然后用矩阵快速幂解决问题了。这里n的范围极大，只能用矩阵快速幂。..
矩阵快速幂算法
果光的博客
03-10 3627
矩阵快速幂算法、利用矩阵快速幂计算斐波那契数列 矩阵快速幂的本质就是 矩阵+快速幂，思路没什么变化。 快速幂的思路见之前的 快速幂介绍，这里就不多说了。 至于矩阵的话，知道矩阵是啥，怎么算乘法就可以了。 相关矩阵基础 注：已经了解矩阵的可以跳过本部分内容。 简单来说 n∗mn*mn∗m 的矩阵就是个 nnn 行 mmm 列 的大方块。 矩阵要进行乘法运算必须保证第一个矩阵的列数=第二个矩阵的行数。
快速幂、矩阵快速幂+斐波那契数列（Fibonacci Sequence）
monkeyKnight的博客
03-26 702
1、快速幂 什么是幂？ 可能有人对这个概念并不很清楚。我们来简单的回顾一下。比如n个a相乘，那我们平常的数学表示就是a^n，读作a的n次幂。那么a就是幂的底，n就是幂指数。 快速幂是什么？ 别急，我们通过例子来讲解。 假如需要求A^9。我们的常规做法一定是9个数A相乘算出结果，简单粗暴还很好理解，但是当我们把9该成1000000的时候，你们还会觉得简单吗？而且你会
快速幂 矩阵快速幂
issey的博客
10-22 5037
前言：好像没啥好写的，链接可能还没有更新完 快速幂 快速幂，用于解决当n很大时的情况。通常与取模同时应用。 用最笨的方法求,即。时间复杂度为,而快速幂（附带取模），可以将时间复杂度降低为。 利用倍增的思想，例如，等于，又等于,即,如果n为奇数，,那么换成代码就是： ll Powermod(ll a,ll b) { ll ans=1; a=a%mod; while(b>0) { if(b%2==1) ans=(ans*a)%...
斐波那契矩阵快速幂.cpp
04-15
斐波那契矩阵快速幂模版
算法竞赛——进阶指南——acwing205. 斐波那契 矩阵快速幂
01-03
利用了矩阵结合律，先算出构造递推矩阵自乘...//#define a(i,j) a[(i)*(m+2)+(j)] //m是矩阵的列数 const double PI= acos(-1.0); const int M = 1e5+7; const int mod =10000; /* int head[M],cnt; void init(){cnt=0
fibo-gmp:使用递归幂和 GNU MP 计算斐波那契数
06-15
fibo-GMP 该程序计算斐波那契数列的第 N 个元素。 提出的实现使用执行矩阵乘法和递归供电的迭代算法。 程序用 C99 编写并使用 GNU MP 库。 在页面上阅读有关该方法的更多信息。 只要您链接到 GNU MP，许可证就有效。...
斐波那契数列求解(矩阵相乘、直接累加)
10-11
分别采用矩阵相乘法（分治递归）和直接累加求和的方法求解第n个斐波那契数
高级色系PPT11.pptx
05-08
高级色系PPT11.pptx
node-v7.9.0-linux-x86.tar.xz
最新发布
05-08
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
基于tensorflow的的cnn卷积神经网络的图像识别分类
05-08
【作品名称】：基于tensorflow的的cnn卷积神经网络的图像识别分类 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
### 数据分析概念、使用技巧、优缺点的文章
05-08
数据分析是指通过收集、清洗、处理和解释数据，以发现其中的模式、趋势和关联，从而提供决策支持或洞察见解的过程。它在各行各业中都扮演着至关重要的角色，从市场营销到科学研究，从金融领域到医疗保健，都有广泛的应用。
矩阵快速幂求斐波那契数列循环输入代码
09-23
以下是矩阵快速幂求斐波那契数列循环输入代码： #include <bits/stdc++.h> using namespace std; typedef long long ll; const int mod = 1e9 + 7; struct Matrix { ll a[2][2]; Matrix() { memset(a, , sizeof(a)); } Matrix operator*(const Matrix& b) const { Matrix res; for (int i = ; i < 2; i++) { for (int j = ; j < 2; j++) { for (int k = ; k < 2; k++) { res.a[i][j] += a[i][k] * b.a[k][j] % mod; res.a[i][j] %= mod; } } } return res; } }; Matrix qpow(Matrix a, ll b) { Matrix res; res.a[][] = res.a[1][1] = 1; while (b) { if (b & 1) res = res * a; a = a * a; b >>= 1; } return res; } int main() { ll n; while (cin >> n) { if (n == -1) break; if (n == ) { cout << << endl; continue; } Matrix base; base.a[][] = base.a[][1] = base.a[1][] = 1; Matrix res = qpow(base, n - 1); cout << res.a[][] << endl; } return ; }

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值