HDU - 4549 M斐波那契数列（矩阵快速幂+费马小定理）

最新推荐文章于 2022-10-26 20:07:04 发布

HelloWorld10086

最新推荐文章于 2022-10-26 20:07:04 发布

阅读量627

点赞数

CC 4.0 BY-SA版权

分类专栏：矩阵快速幂文章标签： hdu 4549

本文链接：https://blog.youkuaiyun.com/HelloWorld10086/article/details/43939779

矩阵快速幂专栏收录该内容

4 篇文章

订阅专栏

本文介绍了一种使用矩阵快速幂方法计算斐波那契数列的方法，并通过费马小定理优化模运算过程，避免了大整数溢出的问题。提供了完整的AC代码实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

解析：

写出f(2),f(3),f(4),f(5) ………可以发先 a b的系数是一系列的fib数列如果可以求出fib数列求快速幂就可以了这样问题就在于如何求fib数列了
很容易想到用矩阵法。

另外注意在矩阵相乘的时候会溢出要用long long 如果对1000000007求余的话依旧会溢出（如果对它求余就错）
但是可以这样做利用下面定理
当gcd(A,M)==1的时候
A^X = A^( X mod Eular(M) ) ( mod M ) .
这样我们只需对1000000006求余

对于本题
f(n)是斐波那契数列的第n项
f(n) = a^f(n-1)*b^f(n)
然后由费马小定理
a^f(n-1) = a^(f(n-1)%1000000006) (mod 1000000007)
b^f(n) = b^(f(n)%1000000006) (mod 1000000007)

AC代码：

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <cstdlib>
using namespace std;
typedef __int64 ll;
const int INF = 0x3f3f3f3f;
const int MOD = 1000000007;
const int SIZE = 2;
struct Matrix {
    ll v[SIZE][SIZE];
    Matrix() {
        memset(v, 0, sizeof(v));
    }
    void init(ll _v) {
        for(int i = 0; i < SIZE; i++)
            v[i][i] = _v;
    }
};
Matrix operator * (Matrix a, Matrix b) {
    Matrix c;
    for(int i = 0; i < SIZE; i++) {
        for(int j = 0; j < SIZE; j++) {
            c.v[i][j] = 0;
            for(int k = 0; k < SIZE; k++) {
                c.v[i][j] += (a.v[i][k] * b.v[k][j]) % (MOD-1);
                c.v[i][j] %= (MOD-1);
            }
        }
    }
    return c;
}
Matrix operator ^ (Matrix a, ll k) {
    Matrix c;
    c.init(1);
    while(k) {
        if(k & 1)
            c = a * c;
        a = a * a;
        k >>= 1;
    }
    return c;
}
ll quick_pow(ll a, ll k) {
    ll s = 1;
    while(k) {
        if(k & 1)
            s = s * a % MOD;
        k >>= 1;
        a = a * a % MOD;
    }
    return s;
}
int main() {
    ll a, b, n;
    while(scanf("%I64d %I64d %I64d", &a, &b, &n) != EOF) {
        Matrix F, A, ret;
        A.v[0][0] = 1, A.v[0][1] = 1;
        A.v[1][0] = 1, A.v[1][1] = 0;

        F.v[0][0] = 1, F.v[0][1] = 1;
        F.v[1][0] = 0, F.v[1][1] = 0;
        if(n == 0) {
            printf("%I64d\n", a);
        }else if(n == 1) {
            printf("%I64d\n", b);
        }else {
            ret = F * (A^(n-2));
            ll ans = quick_pow(a, ret.v[0][1]) * quick_pow(b, ret.v[0][0]) % MOD;
            printf("%I64d\n", ans % MOD);
        }
    }
    return 0;
}