矩阵乘法优化递推

矩阵加减法

对于矩阵\(A\pm B=C\)，直接把每一个位置的两个元素相加或相减。
要求：A 和 B 和 C 行列相同

矩阵乘法

如果 A 是个 \(n\times r\) 的矩阵、 B 是个\(r\times m\)的矩阵，则\(A\times B=C\)是个\(n\times m\)的矩阵(图片来自网络，侵删)

\(C_{i,j}=\sum_{k=1}^r A_{i,k}\bullet B_{k,j}\)

1. 不满足交换律\(AB\ne BA\)
2. 满足结合律\((AB)C=A(BC)\)
3. 满足分配率\(A(B+C)=AB+AC\)

矩阵快速幂

求\(A^n\)时，仅当 A 是方阵。由于满足结合律

\[A^n=\left\{ \begin{aligned} A\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ n=1 \\ (A^{\frac{2}{n}})^2\ \ \ \ \ \ \ \ n\% 2==0 \\ (A^{\lfloor\frac{2}{n}\rfloor})^2\ \ \ \ \ n\% 2==1 \end{aligned} \right. \]

直接按普通快速幂思路就行了，建议用重载运算符
对于一个方阵，如果只有左对角线是 1 ，其他都是 0，这个矩阵叫做单位矩阵，相当于乘法运算中的 1 。

矩阵加速递推(例：斐波拉契)

我们已经知道滚动的递推可以处理\(N\le 2\times 10^8\)的情况，但是如果再大一点，是不是没有办法了呢？
设递推数组是 F ，可以发现\(F_i\ \ \ =1\times F_{i-1}+1\times F_{i-2}\)\(F_{i-1}=1\times F_{i-1}+0\times F_{i-2}\)
可以构造矩阵\(\left(\begin{array}{ccc}1 & 1\\1 & 0\\\end{array}\right)\)
可以发现\(\left(\begin{array}{ccc}F_n \\F_{n-1}\end{array}\right)=\left(\begin{array}{ccc}1 & 1\\1 & 0\\\end{array}\right) \times\left(\begin{array}{ccc}F_{n-1} \\F_{n-2}\end{array}\right)\\\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ =\left(\begin{array}{ccc}1 & 1\\1 & 0\\\end{array}\right)\times\left(\begin{array}{ccc}1 & 1\\1 & 0\\\end{array}\right)\times\left(\begin{array}{ccc}F_{n-2} \\F_{n-3}\\\end{array}\right)\\\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ =\left(\begin{array}{ccc}1 & 1\\1 & 0\\\end{array}\right)^{n-2}\times\left(\begin{array}{ccc}F_2 \\F_1\\\end{array}\right)\\\)
所以就是求\(\begin{equation}\left(\begin{array}{ccc}1 & 1\\1 & 0\\\end{array}\right)\end{equation}^{n-2}\)的结果的左上角和右上角的和就行了

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const LL mod=1000000007;
struct mat {
	LL a[3][3];
	mat() { memset(a,0,sizeof(a)); }
	inline mat operator *(mat x) {
		mat res;
		for(int i=1;i<3;i++)
			for(int j=1;j<3;j++)
				for(int k=1;k<3;k++)
					(res.a[i][j]+=a[i][k]*x.a[k][j])%=mod;
		return res;
	} 
}tmp,res;
LL n;
inline void Pow(LL p) {
	for(;p;p>>=1,tmp=tmp*tmp)
	if(p&1)res=res*tmp;
}
int main() {
	scanf("%lld",&n);
	if(n<3)return puts("1"),0;
	res.a[1][1]=1;
	res.a[1][2]=0;
	res.a[2][1]=1;
	res.a[2][2]=0;
	
	tmp.a[1][1]=1;
	tmp.a[1][2]=1;
	tmp.a[2][1]=1;
	tmp.a[2][2]=0;
	
	Pow(n-2);
	printf("%lld",(res.a[1][1]+res.a[1][2])%mod);
}

例二

递推\( F_i\ \ \ =1\times F_{i-1}+0\times F_{i-2}+1\times F_{i-3} \\ F_{i-1}=1\times F_{i-1}+0\times F_{i-2}+0\times F_{i-3} \\ F_{i-2}=0\times F_{i-1}+1\times F_{i-2}+0\times F_{i-3} \\ \)
得到矩阵\(\left(\begin{array}{ccc}1 & 1 & 0\\1 & 0 & 0\\0 & 1 & 0\\\end{array}\right)\)，跑一遍快速幂
要注意快速幂 \(N\) 次算出的是 \(F_{N+1}\) 所以输出 \(F.A_{2,1}\)

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const LL mod=1000000007;
struct mat {
	int a[4][4];
	mat() { memset(a,0,sizeof(a)); }
	inline mat operator *(mat x) {
		mat res;
		for(int i=1;i<4;i++)
			for(int j=1;j<4;j++)
				for(int k=1;k<4;k++)
					(res.a[i][j]+=1LL*a[i][k]*x.a[k][j]%mod)%=mod;
		return res;
	} 
}tmp,res;
int n,T;
inline void Pow(int p) {
	for(;p;p>>=1,tmp=tmp*tmp)
	if(p&1)res=res*tmp;
}
int main() {
	scanf("%d",&T);
	while(T--) {
		scanf("%d",&n);
		if(n<4) {
			puts("1");
			continue;
		}
		res.a[1][1]=1;
		res.a[1][2]=0;
		res.a[1][3]=0;
		res.a[2][1]=0;
		res.a[2][2]=1;
		res.a[2][3]=0;
		res.a[3][1]=0;
		res.a[3][2]=0;
		res.a[3][3]=1;
		
		tmp.a[1][1]=1;
		tmp.a[1][2]=0;
		tmp.a[1][3]=1;
		tmp.a[2][1]=1;
		tmp.a[2][2]=0;
		tmp.a[2][3]=0;
		tmp.a[3][1]=0;
		tmp.a[3][2]=1;
		tmp.a[3][3]=0;
		
		Pow(n);
		printf("%d\n",res.a[2][1]);		
	}
}