【vijos1243】【单调队列优化DP】生产产品

比较有意思的一道单调队列DP

状态:f[i][j]表示前i个产品，其中第j个步骤是在第j个机器人上完成的，且第j+1步必须更换机器人生产完成的最短时间

首先很容易想到一个朴素的DP方程:f[i][j] = min(f[k][p] + sum[i][j] - sum[k][j]) + w(k != j,k ∈[i-l,i-i]),其中sum[i][j]表示第i个机器人完成1-j个步骤所需要的时间，w为更换机器的花费。时间复杂度O(n * m * m * l),不能在时限内完成，需要优化。

首先将方程变形：f[i][j] = min(f[k][p]  - sum[k][j]) + sum[i][j] + w(k != j,k ∈[i-l,i-i])

由于括号内的式子是根据k所确定的一个常量，很容易让人想到单调队列优化，但由于每个机器工作序列是无序的，所以不能简单地使用一个单调队列来转移。考虑到j的范围特别小，所以可以对每一个j单独考虑，并且增加一个决策序列存下决策的下标，这样就可以通过枚举在多个单调队列中转移，优化过后复杂度变为O(n * m * m)，至此成功解决此题。

代码:

#include<cstdio>
#include<cstring>
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxm = 100000 + 10;
const int maxn = 10;
int sum[maxn][maxm];
int f[maxn][maxm];
int que[maxn][maxn][maxm];
int head[maxn][maxn],tail[maxn][maxn];
int n,m,c,l;
void init()
{
	freopen("vijos1243.in","r",stdin);
	freopen("vijos1243.out","w",stdout);
}

inline int min(int a,int b)
{
	return a < b ? a : b;
}

void readdata()
{
	scanf("%d%d%d%d",&m,&n,&c,&l);
	for(int i = 1;i <= n;i++)
	{
		for(int j = 1;j <= m;j++)
		{
			int tmp = 0;
			scanf("%d",&tmp);
			sum[i][j] = sum[i][j-1] + tmp;
		}
	}
}

void solve()
{
	memset(f,0x3f,sizeof(f));
	for(int i = 1;i <= n;i++)
	{
		for(int j = 1;j <= n;j++)
		{
			head[i][j] = 1;
			tail[i][j] = 1;
		}
	}
	for(int i = 1;i <= n;i++)f[i][0] = -c;
	for(int i = 1;i <= m;i++)
	{
		for(int j = 1;j <= n;j++)
		{
			for(int k = 1;k <= n;k++)
			{
				if(j != k)
				{
					while(que[k][j][head[k][j]] + l < i)head[k][j]++;
					f[j][i] = min(f[j][i],f[k][que[k][j][head[k][j]]] - sum[j][que[k][j][head[k][j]]]);
				}
			}
			f[j][i] += sum[j][i] + c;
		}
		for(int j = 1;j <= n;j++)
		{
			for(int k = 1;k <= n;k++)
			{
				if(j != k)
				{
					while(head[j][k] <= tail[j][k] && (f[j][que[j][k][tail[j][k]]] - sum[k][que[j][k][tail[j][k]]] >= f[j][i] - sum[k][i]))--tail[j][k];
					que[j][k][++tail[j][k]] = i;
				}
			}
		}
	}
	int ans = inf;
	for(int i = 1;i <= n;i++)ans = min(ans,f[i][m]);
	printf("%d",ans);
}

int main()
{
	init();
	readdata();
	solve();
	return 0;
}