矩阵快速幂 - hduoj 5667 Sequence -nyoj 301 递推求值

最新推荐文章于 2022-04-26 16:38:25 发布

原创最新推荐文章于 2022-04-26 16:38:25 发布 · 670 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#矩阵快速幂 #快速幂

总结专栏收录该内容

2 篇文章

订阅专栏

本文介绍了一种使用矩阵快速幂方法解决递归公式问题的技术，包括两个具体实例：一是在给定初始条件和参数的情况下，求解递归公式f(n)对特定数取模后的值；二是通过构建矩阵形式，利用费马小定理简化求解过程，最终实现高效求解。文章还提供了相应的代码示例，展示了如何将理论转化为实际编程应用。

nyoj： 301：

给你一个递推公式：

f(x)=a*f(x-2)+b*f(x-1)+c

并给你f(1),f(2)的值，请求出f(n)的值，由于f(n)的值可能过大，求出f(n)对1000007取模后的值。

输入数据有f(1),f(2),a,b,c,n求f(n)对1e9+7取余的值；

由于n的范围很大，所以此时就需要把递推式变成矩阵的形式；

所以直接矩阵快速：

 
#include <cstdio>
#include <algorithm>
using namespace std;

typedef long long ll;
const long long N = 3;
const ll M = 1000007;

int f1, f2, a, b, c, n;
struct mat
{
    int x,y;
    ll arr[N][N];
    mat()
    {
        x = 3, y = 3;
        arr[0][0] = b, arr[0][1] = a, arr[0][2] = c;
        arr[1][0] = 1, arr[1][1] = 0, arr[1][2] = 0;
        arr[2][0] = 0, arr[2][1] = 0, arr[2][2] = 1;
    }
};

mat mul(mat &A, mat &B)
{
    mat C;
    C.x = A.x, C.y = B.y;
    for(int i=0; i<C.x; i++)
    {
        for(int j=0; j<C.y; j++)
        {
            C.arr[i][j] = 0;
            for(int k=0; k<A.x; k++)
                C.arr[i][j] =(C.arr[i][j] + A.arr[i][k] * B.arr[k][j] + M) % M;
        }
    }
    return C;
}

mat pow(mat A, ll n)
{
    mat B;
    B.x = 1, B.y = 3;
    B.arr[0][0] = f2, B.arr[1][0] = f1, B.arr[2][0] = 1;
    while(n > 0)
    {
        if(n&1)
            B = mul(A, B);
        A = mul(A, A);
        n >>= 1;
    }
    return B;
}

void solve()
{
    scanf("%d%d%d%d%d%d", &f1, &f2, &a, &b, &c, &n);
    if(n == 1)
    {
        printf("%d\n",f1);
        return ;
    }
    mat A;
    A = pow(A, n-2);
    printf("%lld\n", A.arr[0][0]);
}

int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        solve();
    }
    return 0;
}

hduoj 5667：

fn=⎧⎩⎨⎪⎪1,ab,abfcn−1fn−2,n=1n=2otherwise
求fn对p取余后的值；

设：g(n)为f(n)的幂
由此式可知，f(n) = a^(b+c*g(n-1) +g(n-2));

将g(n) = c*g(n-1) + g(n-2) + b构建矩阵进行矩阵快速幂，由费马小定理可知矩阵对（p-1）取余；

然后再进行快速幂运算，就可以了；

代码如下：

#include <cstdio>
#include <algorithm>
using namespace std;

typedef long long ll;
const long long N = 3;
const ll M = 1000007;

long long a, b, c, p;
ll n;

struct mat
{
    long long x,y;
    ll arr[N][N];
};

long long gcd(long long a, long long b)
{
    return b ? gcd(b, a % b) : a;
}

mat mul(mat &A, mat &B)
{
    mat C;
    C.x = A.x, C.y = B.y;
    for(long long i=0; i<C.x; i++)
    {
        for(long long j=0; j<C.y; j++)
        {
            C.arr[i][j] = 0;
            for(long long k=0; k<A.y; k++)
                C.arr[i][j] =(C.arr[i][j] + A.arr[i][k] * B.arr[k][j]) % (p-1);
        }
    }
    return C;
}

mat pow(mat A, ll n)
{
    mat B;
    B.x = 1, B.y = 3;
    B.arr[0][0] = b, B.arr[1][0] = 0, B.arr[2][0] = b;
    while(n > 0)
    {
        if(n&1)
            B = mul(A, B);
        A = mul(A, A);
        n >>= 1;
    }
    return B;
}

long long mod_pow(long long a, long long n)
{
    ll res = 1;
    while(n > 0)
    {
        if(n & 1)
            res = res * a % p;
        a = a * a % p;
        n >>= 1;
    }
    return res;
}

void solve()
{
    scanf("%lld%lld%lld%lld%lld",&n, &a, &b, &c, &p);
    if(a == 1)
    {
        printf("%lld\n",1);
        return ;
    }
    long long t = gcd(a, p);
    if(t != 1)
    {
        printf("%lld\n", 0);
        return ;
    }
    mat A;
    A.x = 3, A.y = 3;
    A.arr[0][0] = c, A.arr[0][1] = 1, A.arr[0][2] = 1;
    A.arr[1][0] = 1, A.arr[1][1] = 0, A.arr[1][2] = 0;
    A.arr[2][0] = 0, A.arr[2][1] = 0, A.arr[2][2] = 1;
    A = pow(A, n-2);
    printf("%lld\n",mod_pow(a, A.arr[0][0]));
}

int main()
{
    long long t;
    scanf("%lld",&t);
    while(t--)
    {
        solve();
    }
    return 0;
}