矩阵快速幂

本文只做基础入门，了解矩阵快速幂的基础应用。进阶内容可以去看其他dalao的~~

矩阵乘法

矩阵乘法
$$设A=(a_{ij})是一个m\times x矩阵，B=(b_{ij})是一个s\times n矩阵，那么规定矩阵A和矩阵B的乘积是一个m\times n矩阵C=(c_{ij})$$

$$\begin{array}{c}\left(\begin{array}{ccc}{a}_{11}& a_{12}& a_{13}\\ a_{21}& a_{22}& a_{23}\end{array}\right)\left(\begin{array}{cc}{b}_{11}& b_{12}\\ b_{21}& b_{22}\\ b_{31}& b_{32}\end{array}\right)=\left(\begin{array}{cc}{a}_{11}{b}_{11}+a_{12}{b}_{21}+a_{13}{b}_{31}& a_{11}{b}_{12}+a_{12}{b}_{22}+a_{13}{b}_{32}\\ a_{21}{b}_{11}+a_{22}{b}_{21}+a_{23}{b}_{31}& a_{21}{b}_{12}+a_{22}{b}_{22}+a_{23}{b}_{32}\end{array}\right)\end{array}$$

必须注意: 只有当第一个矩阵（左矩阵）的列数等于第二个矩阵（右矩阵）的行数时，两个矩阵才能相乘。

在矩阵乘法中必须注意矩阵相乘的顺序。矩阵的乘法不满足交换律，即在一般情况下，AB≠BA。

矩阵的乘法不满足交换律，但是满足结合律，这是矩阵快速幂的关键。

矩阵快速幂

在计算一些有递推公式的问题时，我们可以通过矩阵乘法来计算。

例如斐波那契数列。
$$f_n=f_{n-1}+f_{n-2}$$
我们可以构造出一个矩阵T

使得
$$\begin{array}{c}\left(\begin{array}{cc}{f}_{n-1}& f_n\end{array}\right)T=\left(\begin{array}{cc}{f}_n& f_{n+1}\end{array}\right)\end{array}$$

$$T=\begin{array}{c}\left(\begin{array}{cc}0& 1\\ 1& 1\end{array}\right)\end{array}$$

当我们想求斐波那契数列的某一位时，就可以将矩阵乘上n个T

由于矩阵乘法满足结合律，我们计算时可以先利用快速幂的思想来计算矩阵T的乘积。

快速幂的简单理解

#include <iostream>
#include <cstring>

using namespace std;

const int N = 2;

void mul(int c[], int a[], int b[][N])
{
    int temp[N] = {0};
    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < N; j++)
        {
            temp[i] += a[j] * b[j][i];
        }
    }
    memcpy(c, temp, sizeof temp);
}

void mul(int c[][N], int a[][N], int b[][N])
{
    int temp[N][N] = {0};
    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < N; j++)
        {
            for (int k = 0; k < N; k++)
            {
                temp[i][j] += a[i][k] * b[k][j];
            }
        }
    }
    memcpy(c, temp, sizeof temp);
}

int main()
{
    int f[2] = {1, 1};
    int a[N][N] = {
        {0, 1},
        {1, 1}
    };
    int n;
    cin >> n;
    n--;
    while (n)
    {
        if (n & 1) mul(f, f, a);
        mul(a, a, a);
        n >>= 1;
    }
    cout << f[0] << endl;
    return 0;
}

下代码为求解斐波那契数列的前n项和

#include <iostream>
#include <cstring>

using namespace std;                                                                                                                                                                       

typedef long long ll;

const int N = 3;

int n, m;

void mul(int c[], int a[], int b[][N])                                                                                                                                                     
{                                                                                                                                                                                          
    int temp[N] = {0};                                                                                                                                                                     
    for (int i = 0; i < N; i++)                                                                                                                                                            
    {                                                                                                                                                                                      
        for (int j = 0; j < N; j++)                                                                                                                                                        
        {                                                                                                                                                                                  
            temp[i] = (temp[i] + (ll) a[j] * b[j][i]) % m;
        }                                                                                                                                                                                  
    }
    memcpy(c, temp, sizeof temp);
}

void mul(int c[][N], int a[][N], int b[][N])
{
    int temp[N][N] = {0};
    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < N; j++)
        {
            for (int k = 0; k < N; k++)
            {
                temp[i][j] = (temp[i][j] + (ll) a[i][k] * b[k][j]) % m;
            }
        }
    }
    memcpy(c, temp, sizeof temp);
}

int main()
{
    int f[3] = {1, 1, 1};
    int a[N][N] = {
        {0, 1, 0},
        {1, 1, 1},
        {0, 0, 1}
    };
    cin >> n >> m;
    n--;
    while (n)
    {
        if (n & 1) mul(f, f, a);
        mul(a, a, a);
        n >>= 1;
    }
    cout << f[2] << endl;
    return 0;
}