BZOJ1297 [SCOI2009]迷路 【矩阵优化dp】

题目

windy在有向图中迷路了。 该有向图有 N 个节点，windy从节点 0 出发，他必须恰好在 T 时刻到达节点 N-1。 现在给出该有向图，你能告诉windy总共有多少种不同的路径吗？ 注意：windy不能在某个节点逗留，且通过某有向边的时间严格为给定的时间。

输入格式

第一行包含两个整数，N T。 接下来有 N 行，每行一个长度为 N 的字符串。 第i行第j列为'0'表示从节点i到节点j没有边。 为'1'到'9'表示从节点i到节点j需要耗费的时间。

输出格式

包含一个整数，可能的路径数，这个数可能很大，只需输出这个数除以2009的余数。

输入样例

5 30

12045

07105

47805

12024

12345

输出样例

852

提示

30%的数据，满足 2 <= N <= 5 ； 1 <= T <= 30 。 100%的数据，满足 2 <= N <= 10 ； 1 <= T <= 1000000000 。

题解

设\(f[i][t]\)表示\(t\)时刻到达\(i\)号点的方案数

那么有

\[f[i][t] = \sum\limits_{e(j,i) \in edge} f[j][t - e.w]
\]

\(T\)很大，而且显然这是一个齐次式，考虑矩阵优化

但是矩阵优化只能一层层递推，这里边权的限制使我们可能跨多层

发现边权很小，考虑拆点

每个点拆成一长条链，分别管辖各种权值的出边

这样就可以矩阵优化了

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
#define LL long long int
#define Redge(u) for (int k = h[u],to; k; k = ed[k].nxt)
#define REP(i,n) for (int i = 1; i <= (n); i++)
#define BUG(s,n) for (int i = 1; i <= (n); i++) cout<<s[i]<<' '; puts("");
using namespace std;
const int maxn = 95,maxm = 100005,INF = 1000000000,P = 2009;
inline int read(){
	int out = 0,flag = 1; char c = getchar();
	while (c < 48 || c > 57){if (c == '-') flag = -1; c = getchar();}
	while (c >= 48 && c <= 57){out = (out << 3) + (out << 1) + c - 48; c = getchar();}
	return out * flag;
}
struct Matrix{
	int s[maxn][maxn],n,m;
	Matrix(){n = m = 0; memset(s,0,sizeof(s));}
}F,A;
inline Matrix operator *(const Matrix& a,const Matrix& b){
	Matrix ans;
	if (a.m != b.n) return ans;
	ans.n = a.n; ans.m = b.m;
	for (int i = 1; i <= ans.n; i++)
		for (int j = 1; j <= ans.m; j++)
			for (int k = 1; k <= a.m; k++)
				ans.s[i][j] = (ans.s[i][j] + a.s[i][k] * b.s[k][j] % P) % P;
	return ans;
}
inline Matrix operator ^(Matrix a,int b){
	Matrix ans; ans.n = ans.m = a.n;
	REP(i,ans.n) ans.s[i][i] = 1;
	for (; b; b >>= 1,a = a * a)
		if (b & 1) ans = ans * a;
	return ans;
}
int n,T;
char s[maxn];
int main(){
	n = read(); T = read();
	A.n = A.m = 9 * n;
	REP(i,n){
		scanf("%s",s + 1);
		REP(j,n){
			if (s[j] != '0'){
				int d = s[j] - '0';
				A.s[(j - 1) * 9 + 1][(i - 1) * 9 + d] = 1;
			}
		}
		for (int j = 2; j <= 9; j++)
			A.s[(i - 1) * 9 + j][(i - 1) * 9 + j - 1] = 1;
	}
	F.n = 9 * n; F.m = 1;
	F.s[1][1] = 1;
	Matrix Ans = (A^T) * F;
	printf("%d\n",Ans.s[(n - 1) * 9 + 1][1]);
	return 0;
}