蓝桥杯 ALGO-60 算法训练矩阵乘方

最新推荐文章于 2021-08-04 10:48:12 发布

原创最新推荐文章于 2021-08-04 10:48:12 发布 · 333 阅读

0 ·

CC 4.0 BY-SA版权

蓝桥杯专栏收录该内容

232 篇文章

订阅专栏

本文介绍了一种计算矩阵乘方的快速算法，适用于求解大指数的矩阵幂并对结果取模运算，通过递归分解和模运算提高计算效率。

算法训练矩阵乘方

时间限制：1.0s 内存限制：512.0MB

问题描述

　　给定一个矩阵A,一个非负整数b和一个正整数m，求A的b次方除m的余数。
　　其中一个nxn的矩阵除m的余数得到的仍是一个nxn的矩阵，这个矩阵的每一个元素是原矩阵对应位置上的数除m的余数。
　　要计算这个问题，可以将A连乘b次，每次都对m求余，但这种方法特别慢，当b较大时无法使用。下面给出一种较快的算法(用A^b表示A的b次方)：
　　若b=0，则A^b%m=I%m。其中I表示单位矩阵。
　　若b为偶数，则A^b%m=(A^(b/2)%m)^2%m，即先把A乘b/2次方对m求余，然后再平方后对m求余。
　　若b为奇数，则A^b%m=(A^(b-1)%m)*a%m，即先求A乘b-1次方对m求余，然后再乘A后对m求余。
　　这种方法速度较快，请使用这种方法计算A^b%m，其中A是一个2x2的矩阵，m不大于10000。

输入格式

　　输入第一行包含两个整数b, m，第二行和第三行每行两个整数，为矩阵A。

输出格式

　　输出两行，每行两个整数，表示A^b%m的值。

样例输入

2 2
1 1
0 1

样例输出

1 0
0 1

#include <stdio.h>

void multiply(int a[], int b[], int prod[], int module)
{
    prod[0] = (a[0] * b[0] + a[1] * b[2]) % module;
    prod[1] = (a[0] * b[1] + a[1] * b[3]) % module;
    prod[2] = (a[2] * b[0] + a[3] * b[2]) % module;
    prod[3] = (a[2] * b[1] + a[3] * b[3]) % module;
}

void power(int A[], int b, int m, int ans[])
{
    if (b == 0)
    {
        ans[0] = ans[3] = 1 % m;
        ans[1] = ans[2] = 0;
        return;
    }

    if (b == 1)
    {
        for (int i = 0; i < 4; ++i)
            ans[i] = A[i] % m;
        return;
    }

    if (b % 2 == 0)
    {
        int part[5] = { 0 };
        power(A, b/2, m, part);
        multiply(part, part, ans, m);
    }
    else
    {
        int part1[5] = { 0 }, part2[5] = { 0 };
        power(A, b/2, m, part1);
        multiply(part1, part1, part2, m);
        multiply(part2, A, ans, m);
    }
}

int main()
{
    int A[5] = { 0 }, ans[5] = { 0 };
    int b, m;

    scanf("%d %d", &b, &m);
    for (int i = 0; i < 4; ++i)
        scanf("%d", &A[i]);

    power(A, b, m, ans);

    printf("%d %d\n%d %d", ans[0], ans[1], ans[2], ans[3]);

    return 0;
}