裸的矩阵加速 Floyd。

我们知道 Floyd 可以传递闭包，并且路径的关系也是二元关系（\(i\to k\) 的长度为 \(x\)，\(k\to j\) 的长度为 \(y\)，那么就可以得到 \(i\to j\) 的长度为 \(x+y\)），那么我们就考虑通过类似 Floyd 的方法来做。

我们设 \(f_t[i][j]\) 表示 \(i\to j\) 且长度为 \(t\) 的路径的条数，根据乘法原理，显然可以得到：

\[f_t[i][j]=\sum^n_{k=1}f_{t-1}[i][k]\times f_1[k][j] \]

其中 \(f_1\) 我们发现就是输入的邻接矩阵，而最终答案就是：\(\sum^n_{i=1}\sum^n_{j=1}f_k[i][j]\)

暴力递推去求，时间复杂度是 \(\Theta(kn^3)\)，显然无法接受。

那我们开始考虑 Floyd 的本质。

其实很多人在学 Floyd 的时候，我们发现这一坨东西和矩阵乘法长得很像，而现在这题的 Floyd 的递推式就和矩阵乘法一模一样，就相当于:

\[f_t=f_{t-1}\times f_1 \]

那么就可以得出 \(f_k=f_1^k\)。

矩阵乘法是满足结合律的，那么就可以快速幂来求这个东西，时间复杂度是 \(\Theta(n^3\log n)\)，其中 \(n^3\) 是矩阵乘法自带的复杂度。

代码：

#include<bits/stdc++.h>
using namespace std;
#define rg register
#define int long long 
#define inf 0x3f3f3f3f
#define mod 1000000007
inline int read(){
	rg int ret=0,f=0;char ch=getchar();
    while(!isdigit(ch)){if(ch=='n') return inf; ch=getchar();}
    while(isdigit(ch)){ ret=ret*10+ch-48; ch=getchar(); }
    return f?-ret:ret;
}
struct mul{
	int v[105][105],siz;
	mul(){
		memset(v,0,sizeof(v));
	}
}a;
inline mul operator*(const mul& a,const mul& b){
	mul ret; ret.siz=a.siz;
	for(rg int i=1;i<=ret.siz;++i){
		for(rg int k=1;k<=ret.siz;++k){
			for(rg int j=1;j<=ret.siz;++j){
				ret.v[i][j]+=a.v[i][k]*b.v[k][j]%mod;
				ret.v[i][j]%=mod;
			}
		}
	}
	return ret;
} //矩阵乘法。
inline mul ksm(mul base,int p){
	mul ret; ret.siz=base.siz;
	for(rg int i=1;i<=base.siz;++i) ret.v[i][i]=1;
	while(p){
		if(p&1) ret=ret*base;
		base=base*base; p>>=1;
	}
	return ret;
} //快速幂。
int n,k,ans;
signed main(){
	n=read(); k=read(); a.siz=n;
	for(rg int i=1;i<=n;++i){
		for(rg int j=1;j<=n;++j){
			a.v[i][j]=read();
		}
	}
	mul now=ksm(a,k); //求出 f^k
	for(rg int i=1;i<=n;++i){
		for(rg int j=1;j<=n;++j){
			ans+=now.v[i][j]; ans%=mod;
		}
	}
	printf("%lld",ans);
	return 0;
}
//My bones are titanium,but my heart is made of stars