矩阵快速幂小结

_{版权声明：本文为博主原创文章，遵循CC 4.0 by-sa版权协议，转载请附上原文出处链接和本声明。}

0 前置

---

0.1 什么是矩阵

"矩阵（Matrix）是一个按照长方阵列排列的复数或实数集合”
—— 摘自百度百科

一看就不是人话
其实它就是个二维数组

0.2 矩阵の运算

_{A想直接看乘法的巨佬请自动跳到0.2.3（蒟蒻搞不来锚点）}

• 0.2.1 加法

最基础啦
$$C=A+B⟷C_{i,j}=A_{i,j}+B_{i,j}$$
举个栗子
$$\left[\begin{array}{ccc}1& 2& 3\\ 4& 5& 6\\ 7& 8& 9\end{array}\right]+\left[\begin{array}{ccc}10& 11& 12\\ 13& 14& 15\\ 16& 17& 18\end{array}\right]\text{=}\left[\begin{array}{ccc}11& 13& 15\\ 17& 19& 21\\ 23& 25& 27\end{array}\right]$$
满足交换律和结合律，即$A+B=B+A$，$A+B+C=A+(B+C)$

• 0.2.2 减法

也很基础
和整数运算一样哒，$$A-B=A+(-B)$$
$$\text{即}$$
$$C=A-B⟷C_{i,j}=A_{i,j}-B_{i,j}$$

---

• 0.2.3 乘法

重点来啦！
先敲黑板
不满足交换率！
不满足交换率！！
不满足交换率！！！
至于为什么，我们先看它的定义

两个矩阵的乘法仅当第一个矩阵A的列数和另一个矩阵B的行数相等时才能定义。如A是m×n矩阵和B是n×p矩阵，它们的乘积C是一个m×p矩阵 ，它的一个元素：$c_{i,j}=a_{i,j}{b}_{1,j}+a_{i,2}{b}_{2,j}+\cdots +a_{i,n}{b}_{n,j}={\sum }_{r=1}^n{a}_{i,r}{b}_{r,j}$
—— 摘自百度百科

什么鬼
通俗地来讲，矩阵乘法分这几步(假设$A\cdot B=C$)

1 分A

我们把$A$每行分开
$e.g.$
$$\left[\begin{array}{ccc}1& 2& 3\\ 4& 5& 6\\ 7& 8& 9\end{array}\right]\to [123],[456],[789]$$

2 旋转

把分出来的行转成竖着的列
$e.g.$
$$[123]\to \left[\begin{array}{c}1\\ 2\\ 3\end{array}\right]$$

3 分B

把$B$每一列都分出来（同$A$）

4 计算

经过上面3步，$A,B$都变成了几个列，然后把这几列对应的位置乘起来再相加
$e.g.$
$$\left[\begin{array}{c}1\\ 2\\ 3\end{array}\right]\cdot \left[\begin{array}{c}6\\ 5\\ 4\end{array}\right]\to 1\cdot 6+2\cdot 5+3\cdot 4=28$$
对于$A$的第$i$列和$B$的第$j$列，假设经过如上计算得到了$S$
那么……
$C_{i,j}$就等于$S$啦！
$e.g$
$$A=\left[\begin{array}{cc}1& 2\\ 3& 3\end{array}\right],B=\left[\begin{array}{ccc}5& 4& 4\\ 2& 3& 3\end{array}\right],\text{那么}$$
$C_{1,1}=1\cdot 5+2\cdot 2=9$
$C_{1,2}=1\cdot 4+2\cdot 3=10$
$C_{1,3}=1\cdot 4+2\cdot 3=10$
$C_{2,1}=3\cdot 5+3\cdot 2=21$
$C_{2,2}=3\cdot 4+3\cdot 3=21$
$C_{2,3}=3\cdot 4+3\cdot 3=21$
$$\therefore C=\left[\begin{array}{ccc}9& 10& 10\\ 21& 21& 21\end{array}\right]$$
其实这个过程和定义里写的是等价哒
毕竟百度百科说的都不是人话
某巨佬$wbk$：诶等等，如果进行第4步的时候两列的长度不一样怎么办？比如$\left[\begin{array}{c}1\\ 2\end{array}\right]$和$\left[\begin{array}{c}1\\ 2\\ 3\end{array}\right]$

别急，仔细看矩阵乘法的定义

两个矩阵的乘法仅当第一个矩阵A的列数和另一个矩阵B的行数相等时才能定义

所以矩阵乘法是有前提哒，这样计算才不会出问题（从这儿就能看出为什么不满足交换率，毕竟换个顺序可能就算不了了）

同时注意到若$A$有$a$行，$B$有$b$列，聪明的您肯定很快就会发现$C$为$a$行$b$列的矩阵，便可以确定$C$矩阵的大小。也就是说若$C=A\cdot B$，那么$C$的行的数量不会超过$A$，且列的数量不会超过$B$，所以开数组不需要开额外的大小。

5 code（敲黑板！！！）

能背就背

模板这种东西最好一开始就找一种自己看着舒服的，然后一直写这一种，尽量不要中途更换写法，否则…
—— 某曾换过码风的巨佬的惨案

下面附上本蒟蒻重载运算符的代码（重载运算符后快速幂直接套，比较方便），仅供参考

int n;                                            //矩阵的大小
struct Matrix{                                  
	ll a[MAXN][MAXN];							  //大小视题而定
	Matrix(){memset(a,0,sizeof a);}               //构造函数（不知道什么是构造函数的童鞋们建议学一下，您们可以把初始化的内容放到里面，很方便）
	void Out(){                                   //查错用的（输出矩阵）
		for(register int i=1; i<=n; i++){		 
			for(register int j=1; j<=m; j++)
				printf("%-5lld\n",a[i][j]);
			printf("\n");
		}
	}
	Matrix operator *(Matrix k){                        //重载运算符
		Matrix res;										//这里不写上面那个构造函数的话记得手动初始化一下
		//memset(res.a,0,sizeof(res.a));                //手动初始化
		for(register int i=1; i<=n; i++)          		//枚举A的每一行
			for(register int j=1; j<=n; j++)    		//枚举B的每一列
				for(register int l=1; l<=n; l++)  		//计算
					res.a[i][j] = (res.a[i][j]+a[i][l]*k.a[l][j]%MOD)%MOD;
		return res;
	}
}E;
int main(){
	for(register int i=1; i<=n; i++) E[i][i]=1; 		//构造原始矩阵，相当于整数中的1
}

---

1 矩阵快速幂

1.1 本质

快速幂其实是用来优化乘法的，我们直接看矩阵乘法是拿来优化什么的

矩阵乘法是一种用来优化递推式的东西
—— 某巨佬xinyue

我们观察一下矩阵乘法的计算方式，在$A\cdot B=C$中，对于$A_{i,j}$，它会分别乘以$B$的第$j$行的每一项$B_{j,k}$，然后分别累加到$C_{i,k}$（代码意译）

重点来了
如果$A$只有一行……
那么根据矩阵乘法的性质……
诶，$C$好像也只有一行，而且和$A$有一样的列数
于是我们便可以将$A$和$C$从两个矩阵（二维数组）变成两个长度相同的序列（一维数组）

再看运算过程，用之前的方法，聪明的您会很快地发现经过操作后的$A$只有一列，也就是说对于$C$中的每一项$C_i$，$$C_i=A_1\cdot B_{1,i}+A_2\cdot B_{2,i}+\dots A_n\cdot B_{n,i}$$

注意到$A$的每一项和$B$的行数在运算过程中一直是没变的，在变的只有$B$的列数
于是我们还是采用之前的运算方法，把$B$的每一列提出来，然后…
我们把提出来的每一个序列$i:(b_1,b_2,\dots ,b_n)$抽象成一个操作，把对应的$c(\text{即}{C}_i)$抽象成结果，那么聪明的您会很快地发现：
矩阵的运算本质就是对一个序列$A$进行一堆操作并分别保存所有结果
我们要做的就是构造出初始序列$A$（一般会告诉你）和操作矩阵$B$，套用快速幂优化矩阵乘法，求出答案

---

1.2 举个栗子

著名的斐波那契数列

已知$f_1=1,f_2=1,f_n=f_{n-1}+f_{n-2}$，求$f_n$

首先写出递推式，$$f_n=f_{n-1}+f_{n-2}$$

然后构造出初始序列$A$，注意到推出$f_n$需要知道$f_{n-1},f_{n-2}$
$\therefore A$要包含$f_{n-1}$和$f_{n-2}$
$$\therefore A=[f_{n-1}{f}_{n-2}\dots ](\text{省略号指后面可能还要保存其它东西})$$
注意到$A^{\prime }=[f_n{f}_{n-1}\dots ]$，其中$$f_n=f_{n-1}+f_{n-2}{f}_{n-1}=f_{n-1}$$
$\therefore$ 只保存两项$f_{n-1},f_{n-2}$便可以求出下一个$A^{\prime }$
那么$A$就构造好了：$$A=[f_{n-1}{f}_{n-2}]$$

然后构造操作矩阵$B$
先写出由$A$推出$A^{\prime }$的过程：
$$A^{\prime }=[f_{n-1}+f_{n-2}{f}_{n-1}]=[A_1+A_2{A}_1]$$
考虑结果序列$C$的每一项要对应$A^{\prime }$，稍微变一下形
$$C=A^{\prime }=[A_1\cdot 1+A_2\cdot 1A_1\cdot 1+A_2\cdot 0]$$
聪明的您观察系数便可以很快地发现操作序列分别为：
$$[11]\text{和}[10]$$
所以便很快地构造出操作矩阵$B:$
$$B=\left[\begin{array}{cc}1& 1\\ 1& 0\end{array}\right]$$

先把结果写出来：$$f_n=f_{n-1}+f_{n-2}$$
同时
$$[f_{n-1}{f}_{n-2}]=[f_{n-2}{f}_{n-3}]\cdot B=\cdots =[f_2{f}_1]\cdot B^{n-3}=A\cdot B^{n-3}$$
然后就可以很愉快地用矩阵乘法快速幂求出$A\cdot B^{n-3}$啦！
代码见下面例题

2 例题（不定时更新）

2.1 Luogu P1962 斐波那契数列

题目链接
分析略
$Code$:

#include
using namespace std;

template<typename T>
inline void Read(T &n){
	char ch;bool flag=0;
	while(!isdigit(ch=getchar()))if(ch=='-')flag=1;
	for(n=ch^48;isdigit(ch=getchar());n=(n<<1)+(n<<3)+(ch^48));
	if(flag)n=-n;
}

typedef long long ll;
const ll MOD = 1000000007;

struct Matrix{
	ll a[3][3];
	Matrix(){memset(a,0,sizeof a);}
	void Out(){
		for(register int i=1; i<=2; i++){
			for(register int j=1; j<=2; j++)
				printf("%-5lld\n",a[i][j]);
			printf("\n");
		}
	}
	Matrix operator *(Matrix k){
		Matrix res;
		//memset(res.a,0,sizeof(res.a));
		for(register int i=1; i<=2; i++)
			for(register int j=1; j<=2; j++)
				for(register int l=1; l<=2; l++)
					res.a[i][j] = (res.a[i][j]+a[i][l]*k.a[l][j]%MOD)%MOD;
		return res;
	}
}E,base,f;
ll n;

inline Matrix QuickPow(Matrix Base, ll k){
	Matrix res=E;
	while(k){
		if(k&1)
			res = res*Base;
		Base = Base*Base;
		k>>=1;
	}
	return res;
}

int main(){
	E.a[1][1]=E.a[1][2]=1;
	base.a[1][1]=base.a[1][2]=base.a[2][1]=1;
	f.a[1][1]=f.a[1][2]=1;
	Read(n);
	if(n<=2){
		cout<<1<<endl;
		return 0;
	}
	cout<<(f*QuickPow(base,n-2)).a[1][1]<<endl;
	return 0;
}

2.2 Luogu P1939 【模板】矩阵加速（数列）

题目链接
思路类似，但细节上稍微有些不一样

一次构造

考虑构造初始序列$A$
题目求$f_n$，注意到$$f_n=f_{n-3}+f_{n-1}$$
所以$$A=[f_{n-1}{f}_{n-3}\cdots ]$$
$$A^{\prime }=[f_n{f}_{n-2}\cdots ]$$

二次构造

然后问题来了，$f_n$的确可以推出来，但是$f_{n-2}$却不能用$f_{n-1}$和$f_{n-3}$推出来
所以我们还要再保存几个能推出$f_{n-2}$的值，这里直接保存$f_{n-2}$就好了，于是
$$A=[f_{n-1}{f}_{n-2}{f}_{n-3}\cdots ]$$
$$A^{\prime }=[f_n{f}_{n-1}{f}_{n-2}\cdots ]$$
检查一下，对于$A^{\prime }$的每一项：
$f_n=f_{n-1}+f_{n-3}$
$f_{n-1}=f_{n-1}$
$f_{n-2}=f_{n-2}$
所以$A$便构造出来啦
同时初始序列$A=[111]$

构造操作

再构造操作矩阵$B$
观察前文从$A$递推到$A^{\prime }$的方式，便快速得出操作序列分别为：
$[101]$
$[100]$
$[010]$
再拼在一起（注意这里我们构造的是列，拼的时候要转一下）便得到了操作矩阵$B=\left[\begin{array}{ccc}1& 1& 0\\ 0& 0& 1\\ 1& 0& 0\end{array}\right]$
$$Ans=A\cdot B^n$$
代码就不给了，自己写一写要不然博客太长了

2.3 Vijos 1067 Warcraft III 守望者的烦恼

题目链接

一次构造

构造初始序列$A$
考虑所求值$f_n$，第$n$个位置可以由第$n-1,n-2,n-3,\cdots ,n-k$个位置闪过来，所以递推方程：
$$f_n=\sum _{i=n-k}^{n-1}{f}_i$$
所以直接把每一个$f_i$都存进来
$$A=[f_{n-1}{f}_{n-2}\cdots f_{n-k}\cdots ]$$
检验一下
$$A^{\prime }=[f_n{f}_{n-1}\cdots f_{n-k+1}\cdots ]$$
其中
$f_n=f_{n-1}+f_{n-2}+\cdots +f_{n-k}$
$f_{n-1}=f_{n-1}$
$\cdots$
$f_{n-k+1}=f_{n-k+1}$
所以可以从$A$递推出$A^{\prime }$

构造操作

对于$f_n$，操作序列为$[11\cdots 1](k\text{个})$
对于其他的项，操作序列分别为：
$[1000\cdots 0]$
$[0100\cdots 0]$
$[0010\cdots 0]$
$\cdots$
$[000\cdots 10]$
$$\therefore B=\left[\begin{array}{ccccc}1& 1& 0& \cdots & 0\\ 1& 0& 1& \cdots & 0\\ & & \cdots & & \\ 1& 0& 0& \cdots & 1\\ 1& 0& 0& \cdots & 0\end{array}\right]$$

2.4 等比数列求和

未知来源
众所周知等比数列有求和公式可以直接用，然而某毒瘤出题人xinyue就是要让你对合数取模，所以我们就考虑不用除法的方法——矩阵快速幂！（当然，大佬们可以随意用数论处理合数模数的方法暴踩我）

一次构造

显然 $S_n=S_{n-1}+p^n$
所以构造$$A=[S_{n-1}{p}^{n-1}]$$
考虑递推$A^{\prime }=[S_n{p}^n]$
递推过程显然
$S_n=S_{n-1}+p^{n-1}$
$p^n=p^{n-1}\cdot p$
$A$便构造好啦

构造操作

再构造操作矩阵，同样观察系数构造出操作序列：
$[11]$
$[0p]$
于是操作矩阵$B=\left[\begin{array}{cc}1& 0\\ 1& p\end{array}\right]$

3 小结

3.1 难点

很多人都以为矩阵快速幂难点在于递推式，其实我觉得它真正的重难点在于构造初始序列$A$，但这其实也是一个很简单的过程。这个过程和$BFS$十分地相似，先将所求的$f_n$存入“队列”，每次取出“队头”，将推出“队头”需要的东西再次存入“队列”，直到“队列”为空为止。

3.2 常见问题

矩阵快速幂的操作矩阵$B$可以有很多种不同的样子，毕竟初始序列$A$可以有很多不同的写法，所以当你发现你和小伙伴的写法不一样的时候，不要去盲目修改自己的写法。毕竟一万个矩阵快速幂的题解有一万种不同的操作矩阵

3.3 建议

把矩阵用结构体存起来，同时重载乘号，这样写快速幂的时候可以直接套用快速幂的模板，而且代码看起来也很简洁

4 致谢

感谢wbk大佬用一晚上的时间和我一起研究矩阵
感谢xinyue的题库和讲解