两类递推数列

此博客是抄论文的，你可以认为是转载的

1.线性递推数列

有限数列显然是线性递推数列。
无限数列 $a_i$设其生成函数为 $A(x)$
那么如果 $A(x)$能被表示为 $\frac {C(x)}{B(x)}$的形式，其中 $B(x)[x^0] = 1$，则 $A(x)$是线性递推数列。
常数项为 $1$是因为递推式你要让 $\sum_{j=0}b_ja_{i-j} = 0$来递推出 $a_i$所以常数项需要为 $1$。
能这样表示是因为线性递推实质上就是 $A(x)B(x) = C(x)$，其中 $B(x)$是我们的线性递推式。

对于一个线性递推数列 $a_i$，假设他前 $i$项的最短递推式是 $R^{(i)}$，长度为 $l_i$，那么如果 $R^{(i-1)}$不是前 $i$项的最短递推式，那么有 $l_i \geq \max(l_{i-1},i+1-l_{i-1})$，且这个等号是可以通过构造取到的。
首先 $l_i \geq l_{i-1}$显然，如果 $l_i \leq i-l_{i-1}$的话：

实在不知道怎么用语言表示交换和号。
也就是说如果 $l_i \leq i-l_{i-1}$那么原来的递推式必可以继续用。

接下来我们给出在 $R^{(i-1)}$不是前 $i$项的递推式时 $l_i = \max(l_{i-1},i+1-l_{i-1})$的构造方案，也就是 $BM$算法。

也就是说每次增长递推式，我们都可以用这个方法使得增长时 $l_i = \max(l_{i-1},i+1-l_{i-1})$，不增长时 $l_i = l_{i-1}$。
因为上文证明了 $l_i \geq \max(l_{i-1},i+1-l_{i-1})$，所以这个算法对于有限长度的数列求出的递推式一定是最短的。

对于无限长的数列，

所以我们只需要取最短递推式长度的两倍即可。
边界情况：第一次增长递推式的时候， $a_i$应该是第一个非 $0$元素，那么 $l_i = i$个 $0$即为前 $i$个数的最短递推式，也就是根本没有递推，同时也满足 $l_i \geq i+1-l_{i-1},(l_{i-1}=0)$。
这里需要纠正一个错误观念，一个最短线性递推式的最后一项是可以为 $0$的，因为假如一个长度为 $n$的递推式 $F(x)$对于 $a_n = \sum_{i=1}^n F(x)[x^i]a_{n-i}$不成立，我们需要在递推式的最后补一个 $0$，这样 $a_n$就不在递推式成立的范围内。
也就是说一个线性递推数列被表示为 $\frac {S(x)}{R(x)}$的形式，则它的递推式的长度是 $R(x)$的次数和 $S(x)$的次数加一取 $\max$。

线性递推求第 $n$项：

代码：luogu【模板】Berlekamp-Massey算法

$\mathcal Code:$(真的很短。)

#include<bits/stdc++.h>
#define rep(i,j,k) for(int i=(j),LIM=(k);i<=LIM;i++)
#define per(i,j,k) for(int i=(j),LIM=(k);i>=LIM;i--)
#define maxn 10005
#define pb push_back
#define vi vector<int>
#define mod 998244353
using namespace std;

int n,m,a[maxn];
int Pow(int b,int k){ int r=1;for(;k;k>>=1,b=1ll*b*b%mod) if(k&1) r=1ll*r*b%mod;return r; }
vi BM(int *a,int n){ // a[0 ~ n] is used
	vi r(1,1),p,t;int lt;
	rep(i,0,n){
		int d=0;
		rep(j,0,r.size()-1) d = (d + r[j] * 1ll * a[i-j]) % mod;		
		if(!d) continue;
		t = r;
		r.resize(max(r.size() , i+2-(r.size()-(r.size()!=0))));
		rep(j,0,p.size()-1) r[j+i-lt] = (r[j+i-lt] - 1ll * d * p[j]) % mod;
		int iv = Pow(d , mod-2);
		p = t , lt = i;
		rep(i,0,p.size()-1) p[i] = 1ll * p[i] * iv % mod;
	}
	return r; // a \times r = const 
}
typedef vi poly;
poly Mul(const poly &A,const poly &B,const poly &P){
	poly r(A.size() + B.size() - 1);
	rep(i,0,A.size()-1) rep(j,0,B.size()-1) r[i+j] = (r[i+j] + 1ll * A[i] * B[j]) % mod;
	per(i,r.size()-1,P.size()-1) if(r[i]){// in this problem P[P.size()-1] = 1 , so there is no need to getinv.
		int t = r[i];
		rep(j,1,P.size())
			r[i-j+1] = (r[i-j+1] - 1ll * P[P.size()-j] * t) % mod;
	}
	r.resize(P.size()-1);
	return r;
}

int main(){
	scanf("%d%d",&n,&m);
	rep(i,0,n-1) scanf("%d",&a[i]);
	vi P = BM(a,n-1);
	rep(i,1,P.size()-1) printf("%d%c",(mod-(P[i]+mod)%mod) % mod," \n"[i==P.size()-1]);
	reverse(P.begin(),P.end());
	poly r(1,1),t(2,0);
	t[1] = 1;
	for(;m;m>>=1,t=Mul(t,t,P)) if(m&1)
		r = Mul(r,t,P);
	int ans = 0;
	rep(i,0,r.size()-1) ans = (ans + 1ll * r[i] * a[i]) % mod;
	printf("%d\n",(ans+mod)%mod);
}

向量序列的最短递推式：

矩阵的零化多项式：使得矩阵 $M$：
$f(M) = \sum_{i=0}^n a_iM^i = 0$
矩阵的最小多项式：
零化多项式中次数最低的多项式。
如何求矩阵的最小多项式：
直接求 ${I,M,M^2...}$的最短递推式即可，对于稀疏矩阵可以做到 $O(n(n+e))$。

BM与矩阵的特征多项式：
特征多项式是矩阵的一个零化多项式，
而 $BM$求出的最小多项式也是矩阵的一个零化多项式

最小多项式是特征多项式的一个因式，因为如果不是则可以做带余除法得到余式为更小的零化多项式。
对于一个线性递推问题，我们可以通过零化多项式得到线性递推式，所以在解决线性递推时可以找最小多项式（用BM），也可以求特征多项式。
但是特征多项式的最经典的解法是根据定义 $|\lambda - IE| = 0$来求行列式后拉格朗日插值求出多项式， $O(n^4)$相较于 $BMO(n^3)$感觉没有什么竞争力，尽管特征多项式有 $O(n^3)$的巧妙解法，但是这个解法无法计算出线性递推的前 $n$项（就是不能用递推式的部分），有了前 $n$项那为什么不用 $BM$呢？
综上在信息学奥赛的当前时代最小多项式完爆特征多项式，很多打着特征多项式的旗子的题目都可以用BM解决。

接下来我们看一个例题：
「2018 集训队互测 Day 1」完美的旅行
$n$个点的有向图，一次旅行是走 $a\geq1$步，愉悦值为起点和终点的编号 $and$和。
多次旅行的愉悦值是每次旅行的 $and$和，对于所有的愉悦值 $0\leq x\lt n$和 $1\leq a \leq m$的总步数，求愉悦值为 $x$总步数为 $a$的多次旅行方案数。

先求 $and$为集合 $S$的超集的方案数 $f_S$，然后用 $FMT$一次就可以求出 $and$为集合 $S$的方案数。
$and$为集合 $S$的超集的一次旅行走了 $a$步，可以发现就是邻接矩阵 $A$的 $a$次方的一些位置的和。
大小为 $n$的矩阵一定有次数 $\leq n$的特征多项式，所以一次旅行的走了 $a$步的那些答案就是一个 $n$阶线性递推。
假设一次旅行的生成函数为 $G(x)$，则多次旅行的生成函数为 $F(x) = \frac 1{1 - G(x)}$
因为 $G(x)$为 $n$阶递推，所以 $G(x) = \frac {S(x)}{R(x)}$，其中 $R(x)$次数 $\leq n$, $S(x)$次数 $\leq n-1$。
$F(x) = \frac {R(x)}{R(x) - S(x)}$，分子次数可以为 $n$，所以 $F(x)$是 $n+1$阶线性递推。

2.整式递推数列