OIer 矩阵乘法的各种类型及应用总结

矩阵乘法的各种总结

矩阵乘法的计算规则与代码模板

为了后面方便统一，先给出一个统一的规则（虽然有其他的版本）。

有两个矩阵相乘 $A\times B=C$ 当且仅当 $A$ 的列数 与 $B$ 的行数相等，那么 $C$ 的行数则与 $A$ 的行数相等，$C$ 的列数 与 $B$ 的列数相等

$A$ 的第一行的各个数分别于 $B$ 的第一列的各个数对应相乘的和 为 $C$ 的第一行第一列

$A$ 的第一行的各个数分别于 $B$ 的第二列的各个数对应相乘的和 为 $C$ 的第一行第二列

$A$ 的第二行的各个数分别于 $B$ 的第一列的各个数对应相乘的和 为 $C$ 的第二行第一列

$\cdots$

其余同理

模板如下

class Matrix {
    public:
        int mx[2 * N + 5][2 * N + 5];
        int row, col;
        Matrix (int n = 0, int m = 0, bool unit = 0) {
            row = n;
            col = m;
            memset(mx, 0, sizeof mx);
            if (unit && n == m) {
                for (int i = 1; i <= n; i ++) {
                    mx[i][i] = 1;
                }
            }
        }

        Matrix operator * (const Matrix& other) const {
            if (col != other.row) return Matrix(0, 0);
            Matrix result(row, other.col);
            for (int i = 1; i <= row; i ++) {
                for (int j = 1; j <= other.col; j ++) {
                    for (int k = 1; k <= col; k ++) {
                        result.mx[i][j] = (result.mx[i][j] + mx[i][k] * other.mx[k][j]) % Mod;
                    }
                }
            }
            return result;
        }

        Matrix qpow (int b) {
            if (col != row) return Matrix(0, 0);
            Matrix result (row, col, 1);
            Matrix A = (*this);
            while (b) {
                if (b & 1) result = result * A;
                A = A * A;
                b >>= 1;
            }
            return result;
        }
};

矩阵乘法优化 DP

对于形如 $F_n=a_1\times F_{n-1}+a_2\times F_{n-2}+\cdots +a_k\times F_{n-k}$ 的 dp 方程，我们可以使用矩阵乘法进行优化。

矩阵递推的形式如下

$${\left[\begin{array}{c}系数矩阵\end{array}\right]}^T\times \left[\begin{array}{c}递推矩阵\end{array}\right]=\left[\begin{array}{c}答案矩阵\end{array}\right]$$

先忽略系数矩阵的 $T$ 次方，后面会解释，我们想要知道 $F_n$ 显然要知道 $F_{n-1},F_{n-2},\cdots ,F_{n-k}$ 因此递推矩阵中一定含有这几项，那么答案矩阵由递推矩阵得来显然与递推矩阵形式一致，因此我们可以填上一下两个矩阵

$$
\begin{bmatrix}&&&&&\&系&数&矩&阵\&&&&&\\end{bmatrix} \times \begin{bmatrix}F_{n - 1}\F_{n - 2}\F_{n - 3}\\cdots \F_{n - k}\end{bmatrix} =\begin{bmatrix}F_n\F_{n - 1}\F_{n - 2}\\cdots \F_{n - k + 1}\end{bmatrix}

$$

并且根据矩阵乘法规则，我们可以知道系数矩阵的大小为 $k\ast k$ 的，现在我们要构造这个矩阵

$$\left[\begin{array}{cccc}{A}_{1,1}& A_{1,2}& \cdots & A_{1,k}\\ \cdots & \cdots & \cdots & \cdots \end{array}\right]\times \left[\begin{array}{c}{F}_{n-1}\\ F_{n-2}\\ F_{n-3}\\ \cdots \\ F_{n-k}\end{array}\right]=\left[\begin{array}{c}{F}_n\\ F_{n-1}\\ F_{n-2}\\ \cdots \\ F_{n-k+1}\end{array}\right]$$

其中 $A_{1,1}\times F_{n-1}+A_{1,2}\times F_{n-2}+\cdots +A_{1,k}\times F_{n-k}=F_n$ （矩阵乘法的规则）

由递推式可知 $A_{1,1}=a_1,A_{1,2}=a_2,\cdots A_{1,k}=a_k$

我们已经完成了系数矩阵第一行的构造， 接下来就很简单了

$$\left[\begin{array}{cccc}\cdots & \cdots & \cdots & \cdots \\ A_{2,1}& A_{2,2}& \cdots & A_{2,k}\\ \cdots & \cdots & \cdots & \cdots \end{array}\right]\times \left[\begin{array}{c}{F}_{n-1}\\ F_{n-2}\\ F_{n-3}\\ \cdots \\ F_{n-k}\end{array}\right]=\left[\begin{array}{c}{F}_n\\ F_{n-1}\\ F_{n-2}\\ \cdots \\ F_{n-k+1}\end{array}\right]$$

因为 $F_{n-1}$ 已经在递推矩阵中出现了因此我们直接用就好了，让 $A_{2,1}$ 为 $1$ 其余全部为 $0$ 即可。

相当于 $1\times F_{n-1}+0\times F_{n-2}+\cdots +0\times F_{n-k}=F_{n-1}$，剩下的 $k-2$ 行依次构造即可。

最后递推矩阵每乘上一个系数矩阵相当于多往后递推一位, 因此就有了前文所述的 $T$ 次方。

矩阵的等比数列求和

若有一个矩阵 $A$，求 $A+A^1+A^2+A^3+\cdots +A^n$ 的和

因为要求和，所以说和一定要在答案矩阵里，那么不妨设 $S_n=A+A^1+\cdots +A^n$，则递推式相当于 $S_n=S_{n-1}\times A+A$

构造矩阵 (过程略) 得:

$$\left[\begin{array}{cc}A& Uni{t}_1\\ Uni{t}_0& Uni{t}_1\end{array}\right]\times \left[\begin{array}{c}{S}_{n-1}\\ A\end{array}\right]=\left[\begin{array}{c}{S}_n\\ A\end{array}\right]$$

其中 $Uni{t}_1$ 是左上至右下对角线为 $1$ 的单位矩阵，$Uni{t}_0$ 是一个全零矩阵，他们的大小都是与 $A$ 相同的，相当于扩大了一倍

与上同理快速幂转移。

矩阵乘法在图论中的应用

其实，当我们用邻接矩阵存图的时候相当于构造了一个$n\times n$的矩阵，那么这个矩阵自乘一次有什么意义呢？

我们来看一下 $Floyd算法$:

for (int k = 1; k <= n; k ++) {
    for (int i = 1; i <= n; i ++) {
        for (int j = 1; j <= n; j ++) {
            dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
        }
    }    
}

发现它和矩阵乘法很像，其实如果我们把这个更新的结果放在一个新的数组而不是 $dis$ 那么我们会得到一个$类Floyd算法$ 可以通过矩阵快速幂实现$O(logN)$ 的得到 从 $i$ 到 $j$ 恰好经过 $N$ 条边的最短路

现在我们在改一下 $dis$ 的定义：

$$di{s}_{i,j}表示从i到j的方案数$$

那么 $Floyd算法$就应该写成这样

for (int k = 1; k <= n; k ++) {
    for (int i = 1; i <= n; i ++) {
        for (int j = 1; j <= n; j ++) {
            dis[i][j] = dis[i][j] + dis[i][k] * dis[k][j];
        }
    }    
}

标准的矩阵乘法形式

那么 $类Floyd算法$ 同理可以维护：从 $i$ 到 $j$ 恰好经过 $N$ 条边的方案数

那么，如果我们相求从 $i$ 到 $j$ 恰好经过 $\le N$ 条边的方案数

你应该已经想到了，这不就是答案矩阵 $A$ 的 $A+A^1+A^2+A^3+\cdots +A^N$ 吗？

上面的做法时空是 $O(4N)$ 的， 其实还有一种更好的方法

$$\left[\begin{array}{cccccc}di{s}_{1,1}& di{s}_{1,2}& di{s}_{1,3}& \cdots & di{s}_{1,n}& 0\\ di{s}_{2,1}& di{s}_{2,2}& di{s}_{2,3}& \cdots & di{s}_{2,n}& 0\\ \cdots & \cdots & \cdots & \cdots & \cdots & 0\\ di{s}_{n,1}& di{s}_{n,2}& di{s}_{n,3}& \cdots & di{s}_{n,n}& 0\\ 1& 0& 0& \cdots & 0& 1\end{array}\right]$$

多添一行一列 $0$ 在矩阵的最后，然后将起始点的对应列的最后一个修改为 $1$ 如图则表示从 $1$ 号点出发，矩阵的右下角设为 $1$

这个 $1$ 是可以修改的。同理让矩阵自乘$N$次即可。

最后的答案就在终点的对应列的最后一行