foj 1692 矩阵快速幂&&循环矩阵优化

87 阅读 0 评论 58 点赞

我是靠谱客的博主爱听歌白云，最近开发中收集的这篇文章主要介绍foj 1692 矩阵快速幂&&循环矩阵优化，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

这题首先要构造一个矩阵来模拟递推的过程这是很简单的

难度在于即使这样用了快速幂优化之后还是会TLE

那么就需要继续优化

怎么优化呢？

通过观察可以发现我们构造的矩阵是循环矩阵。什么是循环矩阵呢？

形式为的矩阵为循环矩阵

就是说下一行的值能够通过上一行的值右移得到

循环矩阵有一个性质就是：

对于两个循环矩阵 A 与 B 来说，A + B 也是循环矩阵。AB 也是循环矩阵，并且 AB=BA

因此可以优化矩阵的乘法从o（n^3）优化到o（n^2）

这样就不会TLE了

AC代码如下：

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

const int MAX_N = 101;

__int64 MOD;
int N, M, L, R;

void multipy( __int64 a[][MAX_N], int am, int an, __int64 b[][MAX_N], int bm, int bn, __int64 c[][MAX_N] ){
    for( int i = 1; i <= am; i++ ){
        for( int j = 1; j <= bn; j++ ){
            c[i][j] = 0;
            for( int k = 1; k <= an; k++ ){
                c[i][j] = ( c[i][j] + a[i][k] * b[k][j] ) % MOD;
            }
        }
    }
}

void multipy1( __int64 a[][MAX_N], int am, int an, __int64 b[][MAX_N], int bm, int bn, __int64 c[][MAX_N] ){
    for( int i = 1; i <= 1; i++ ){
        for( int j = 1; j <= bn; j++ ){
            c[i][j] = 0;
            for( int k = 1; k <= an; k++ ){
                c[i][j] = ( c[i][j] + a[i][k] * b[k][j] ) % MOD;
            }
        }
    }
    for( int i = 2; i <= am; i++ ){
        c[i][1] = c[i-1][bn];
        for( int j = 2; j <= bn; j++ ){
            c[i][j] = c[i-1][j-1];
        }
    }
}

void get_pow( __int64 a[][MAX_N], __int64 n ){
    __int64 ans[MAX_N][MAX_N] = {0};
    __int64 temp[MAX_N][MAX_N];
    for( int i = 1; i <= N; i++ ){
        ans[i][i] = 1;
    }
    while( n ){
        if( n % 2 == 1 ){
            multipy1( ans, N, N, a, N, N, temp );
            memcpy( ans, temp, sizeof( __int64 ) * MAX_N * MAX_N );
        }
        multipy1( a, N, N, a, N, N, temp );
        memcpy( a, temp, sizeof( __int64 ) * MAX_N * MAX_N );
        n /= 2;
    }
    memcpy( a, ans, sizeof( __int64 ) * MAX_N * MAX_N );
}

int main(){
    int T;

    scanf( "%d", &T );
    while( T-- ){
        scanf( "%d%d%d%d%I64d", &N, &M, &R, &L, &MOD );
        __int64 a[MAX_N][MAX_N];
        __int64 b[MAX_N][MAX_N];
        __int64 c[MAX_N][MAX_N];
        memset( a, 0, sizeof( a ) );
        memset( b, 0, sizeof( a ) );
        memset( c, 0, sizeof( a ) );
        for( int i = 1; i <= N; i++ ){
            scanf( "%I64d", &b[i][1] );
        }
        a[1][2] = R % MOD; a[1][N] = L % MOD;
        a[N][1] = R % MOD; a[N][N-1] = L % MOD;
        for( int i = 2; i < N; i++ ){
            a[i][i-1] = L % MOD;
            a[i][i+1] = R % MOD;
        }
        for( int i = 1; i <= N; i++ ){
            a[i][i] = 1;
        }
        get_pow( a, M );
        multipy( a, N, N, b, N, 1, c );
        printf( "%I64d", c[1][1] );
        for( int i = 2; i <= N; i++ ){
            printf( " %I64d", c[i][1] );
        }
        puts("");
    }
    return 0;
}