题意：中文题。不说了。
注意一些地方，机器的执行过程是没有顺序的，而且每个机器可以用多次。第一次执行的机器不消耗转移时间K。
用dp[i][j]表示第i个机器完成第j个步骤的最短时间，sum[j][i]表示第i个机器完成前j个步骤的时间。
比较容易想到一个朴素的状态转移方程：
dp[i][j]=min{dp[k][j']+sum[j][i]-sum[j'][i]}+K (j-j'<l),(i!=k)
这里状态是O（n*m)，转移是O(n*l)，一定会超时，需要优化。
方程变形得dp[i][j]=min{dp[k][j']-sum[j'][i]}+sum[j][i]+K
在这里如果把k和i看作常数，那么dp[k][j']-sum[j'][i]是一个只和j'量。由于k和i比较小，我们完全可以枚举k和i的所有情况，我们定义该量为opt[i][k]，我们只需要维护j-l到j这段范围内这个量的最小值即可。这里使用二维的优先队列来解决。转移部分优化成O（n）。总时间可以接受。
笔者曾经一度被初始化部分卡住，所以这里着重解释一下初始化部分的写法。
当j=1时，j唯一可能转移而来的状态就是j=0，所以首先我们要在队列里存入所有队列里存入j=0的下标，但这样还不够，还要更新j=0的状态，j=0时opt[i][k]这个变量是等于0，所以对应opt[i][k]=dp[k][0]+sum[0][i]，需要把dp[k][0]和sum[0][i]都初始化为0。其他情况下，dp[i][j]都初始化为INF。
可以这么写：
memset(dp,0x7f,sizeof(dp));
; i<=n; ++i)
dp[i][]=;
; i<=n; ++i)
; j<=n; ++j)
dq[i][j].push_back();
或者是下标j从0开始枚举，这样就包含了将j=0存入队列的部分，而初始化j=0的状态还是要自己来写。
维护队首和队尾的部分，要一次性全部完成，不能一次维护一个。
最后要注意的一个地方就是第一个机器是不花费转移机器的时间的，所以时间里要减去一个K。
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cstdlib>
#include<string>
#include<vector>
#include<deque>
using namespace std;
][];
][];
deque<][];
int calc(int i,int j,int k)
{
return dp[k][j]-time[j][i];
}
int main()
{
int m,n,K,l;
scanf("%d%d%d%d",&m,&n,&K,&l);
; i<=n; ++i)
{
; j<=m; ++j)
{
int t;
scanf("%d",&t);
time[j][i]=time[j-][i]+t;
}
}
int ans=0x7fffffff;
memset(dp,0x7f,sizeof(dp));
; i<=n; ++i)
dp[i][]=;
; j<=m; ++j)
{
; i<=n; ++i)
; k<=n; ++k)
if(i!=k) while(!dq[i][k].empty()&&(j-dq[i][k].front())>l) dq[i][k].pop_front();
; i<=n; ++i)
; k<=n; ++k)
if(i!=k)
{
,b=;
if(!dq[i][k].empty()) a=calc(i,dq[i][k].front(),k);
b=time[j][i]+K;
dp[i][j]=min(dp[i][j],a+b);
}
; i<=n; ++i)
; k<=n; ++k)
if(i!=k)
{
while(!dq[i][k].empty()&&(calc(i,dq[i][k].back(),k)>=calc(i,j,k))) dq[i][k].pop_back();
dq[i][k].push_back(j);
}
}
; i<=n; ++i)
ans=min(ans,dp[i][m]);
printf("%d\n",ans-K);
;
}