●codeforces 553E Kyoya and Train

题链：

http://codeforces.com/problemset/problem/623/E

题解：

FFT，DP

题意：

一个有向图，给出每条边的起点u,终点v,费用c，以及花费每种时间的概率P[e][j](表示走第e条边花费时间为j的概率)

现在需要从1号点走到n号点，如果不能在T个单位时间内到达，则达到后还要另外支付X的费用。

求出所需支付的最小期望费用。

---

先是一个暴力的DP方法：

（考虑到每条边的耗时至少为1，可以把状态设为类似分层图的形式）

定义$F[i][t]$为$t$时刻在$i$点时，到达终点n所需要的最小期望费用。

不难得到DP转移，枚举每条i点的出边e：

$$F[i][t]=min(c[e]+\sum_{j=1}^{T}P[e][j]\times F[v[e]][t+j])$$

然后令$G[e][t]$表示$t$时刻从${u[e]}$出发到达n点所需要的最小期望费用。

即$$G[e][t]=c[e]+\sum_{j=1}^{T}P[e][j]\times F[v[e]][t+j]$$

所以$$F[i][t]=min(G[e][t])\quad (u[e]=i)$$

这个复杂度为$O(mT^2)$

---

考虑优化，注意到求G的式子有点像卷积的形式。

的确，我们只需要把$P[e]$数组翻转，即可得到：

$$G[e][t]=G'[e][T+t]=c[e]+\sum_{j=1}^{T}P[e][T-j]\times F[v[e]][t+j]$$

这个就可以用FFT做了。

但是我们并不知道P数组所有的值，又怎么办呢？

这时采用分治的方法，（类似CDQ那种）

基于这样一个事实：

$$D_r=\sum_{i=0}^{n-1}f_ig_{r-i}=\sum_{i=0}^{k}f_ig_{r-i}+\sum_{i=k+1}^{n-1}f_ig_{r-i}$$

用文字描述就是：计算卷积时，可以把贡献分成几段来分别计算，

或者说用FFT计算D的值时，可以先计算$\sum_{i=0}^{k}f_ig_{r-i}这个卷积，再加上\sum_{i=k+1}^{n-1}f_ig_{r-i}这个卷积$

所以我们对时间进行分治：

1.对于当前的分治层$t∈[l，r]$，我们先递归处理右边[mid，r]，得到右边所有的F[i][mid~r]，然后用FFT求值去贡献到G[e][l~mid-1]。

2.继续递归处理左边[l,mid-1]。

3.当到达递归最底层即$l=r$时，我们用G去求出所有的$F[i][l]$，因为此时的转移来源$G[e][t](t>l)$都计算完毕。

算法的大体流程就这样，复杂度$O(mTlog^2T)$

具体的实现还需特别注意：

1.FFT时的下标转化感觉有点绕，（我是膜的别人的做法）。

2.当t>给出的T时，由于已经超时，所以就直接按费用最短路前往n点。

3.由于每次求G[e][t]时，需要的来源状态的时间t'<=t+T，所以数组的时间那一维开为2*T即可。

代码：

#include<bits/stdc++.h>
#define MAXN 55
#define MAXM 105
#define MAXT 40005
using namespace std;
const double Pi=acos(-1);
struct Complex{
	double real,image;
	Complex(double _real=0,double _image=0):real(_real),image(_image){}
	Complex operator - () const{return Complex(-real,-image);}
	friend Complex operator + (const Complex &A,const Complex &B){return Complex(A.real+B.real,A.image+B.image);}
	friend Complex operator - (const Complex &A,const Complex &B){return A+(-B);}
	friend Complex operator * (const Complex &A,const Complex &B){return Complex(A.real*B.real-A.image*B.image,A.image*B.real+A.real*B.image);}
}A[65538],B[65538],nul(0,0);
double F[MAXN][MAXT],G[MAXM][MAXT],P[MAXM][MAXT];
int U[MAXM],V[MAXM],C[MAXM],S[MAXN][MAXN];
int order[65538];
int N,M,T,X;
void read(int &x){
	static int sign; static char ch;
	x=0; sign=1; ch=getchar();
	while(ch<'0'||'9'<ch){if(ch=='-')sign=-1;ch=getchar();}
	while('0'<=ch&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
	x=x*sign;
}
void Floyd(){
	memset(S,0x3f,sizeof(S));
	for(int i=1;i<=N;i++) S[i][i]=0;
	for(int e=1;e<=M;e++) S[U[e]][V[e]]=C[e];
	for(int k=1;k<=N;k++)
		for(int i=1;i<=N;i++) if(i!=k)
			for(int j=1;j<=N;j++) if(j!=k&&j!=i)
				S[i][j]=min(S[i][j],S[i][k]+S[k][j]);

}
void FFT(Complex *Y,int n,int sign){
	for(int i=0;i<n;i++) if(i<order[i]) swap(Y[i],Y[order[i]]);
	for(int d=2;d<=n;d<<=1){
		Complex dw(cos(2*Pi/d),sin(sign*2*Pi/d)),w,tmp;
		for(int i=0;w=Complex(1,0),i<n;i+=d)
			for(int k=i;k<i+d/2;w=w*dw,k++)
				tmp=w*Y[k+d/2],Y[k+d/2]=Y[k]-tmp,Y[k]=Y[k]+tmp;
	}
	if(sign==-1) for(int i=0;i<n;i++) Y[i].real/=1.0*n;
}
void contribution(int l,int mid,int r){
	static int m,n,len;  m=r-l+1;
	for(n=1,len=0;n<=m+r-mid;n<<=1) len++;
	for(int i=1;i<n;i++) order[i]=(order[i>>1]>>1)|((i&1)<<(len-1));
	for(int e=1;e<=M;e++){
		for(int i=0;i<n;i++) A[i]=B[i]=nul;
		for(int i=1;i<m;i++) B[i]=Complex(P[e][i],0);
		for(int i=mid;i<=r;i++) A[r-i]=Complex(F[V[e]][i],0);
		FFT(A,n,1); FFT(B,n,1);
		for(int i=0;i<n;i++) A[i]=A[i]*B[i];
		FFT(A,n,-1);
		for(int i=l;i<mid;i++) G[e][i]+=A[r-i].real;
	}
}
void solve(int l,int r){
	if(l==r){
		for(int i=1;i<N;i++) F[i][l]=S[i][N]+X;
		for(int e=1;e<=M;e++)
			F[U[e]][l]=min(F[U[e]][l],C[e]+G[e][l]);
		return;
	}
	int mid=(l+r+1)/2;//向上取整
	solve(mid,r);
	contribution(l,mid,r);
	solve(l,mid-1);
}
int main(){
	read(N); read(M); read(T); read(X);
	for(int e=1,x;e<=M;e++){
		read(U[e]); read(V[e]); read(C[e]);
		for(int i=1;i<=T;i++)
			read(x),P[e][i]=1.0*x/100000;
	}
	Floyd();
	for(int i=1;i<=N;i++)
		for(int j=T+1;j<=2*T;j++)
			F[i][j]=S[i][N]+X;
	for(int j=1;j<=T;j++) F[N][j]=0;
	contribution(0,T+1,2*T);
	solve(0,T);
	printf("%.8lf\n",F[1][0]);
	return 0;
}