[POJ1821]Fence（单调队列优化dp）

[poj1821]Fence

有 N 块木板从左至右排成一行,有 M 个工匠对这些木板进行粉刷,每块木板至多被粉刷一次。第 i 个工匠要么不粉刷,要么粉刷包含木板 Si 的,长度不超过Li 的连续一段木板,每粉刷一块木板可以得到 Pi 的报酬。求如何安排能使工匠们获得的总报酬最多。
1<=N<=16000,1<=M<=100

输入

NK
L1 P1 S1
L2 P2 S2
...
LK PK SK

输出

输出包含一个整数,即最大总收入。

样例输入:

8 4
3 2 2
3 2 3
3 3 5
1 1 7

样例输出:

17
先把所有工匠按照(Si)排序,这样一来,每个工匠粉刷的木板一定在上一个工匠之后,使我们能够按顺序进行线性 DP。
设(F[i,j])表示安排前(i)个工匠粉刷前(j)块木板(可以有空着不刷的木板),工匠能获得的最多报酬。
1.第(i)个工匠可以什么也不刷,此时(F[i,j]=F[i-1,j])。
2.第(j)块木板可以空着不刷,此时(F[i,j]=F[i,j-1])。
3.第(i)个工匠粉刷第(k+1)块到第(j)块木板。根据题意,该工匠粉刷总数不能超过(Si),所以需要满足: (k+1<=Si<=j)并且(j-k<=Li)。于是,有状态转移方程:

[F[i,j]=max(F[i-1,k]+Pi*(j-k)) (j-Li<=k<=Si-1,j>=Si) ]

我们重点来看这个方程怎么优化。首先,在考虑内层循环(j)以及决策(k)时,可把外层循环变量(i)看作定值。这样一来,状态转移方程中的各项可分为两部分:
1.(Pi*j),除定值(i)外,只有状态变量(j)。
2.(F[i-1,k]-Pi*k),除定值(i)外,只有决策变量(k)。状态转移方程可写为:

[F[i,j]=Pi*j+max(F[i-1,k]-Pi*k) ]

当 (j) 增大时,(k) 的取值范围上界 (Si-1) 不变,下界 (j-Li) 变大。这时
我们来比较任意两个决策 (k1) 和 (k2)。不妨设 (k1<k2<=Si-1)。因为 (k2) 比 (k1) 更靠后,所以随着 (j) 的增加,(k1) 会比 (k2) 更早从范围([j-Li,Si-1])中排除。如果还满足(F[i-1,k1]-Pi*k1<=F[i-1,k2]-Pi*k2)那么就意味着 k2 不但比 k1 优,还比 k1 的存活时间更长。在这种情况下,k1 就是一个无用的决策,应该被排除出候选集合。综上所述,我们可以维护一个决策点 k 的单调递增。数值(F[i-1,k]-Pi*k) 单调递减的队列。只有这个队列中的决策才有可能在某一时刻成为最优决策。这个单调队列支持如下操作:
1.当 j 变大时,检查队头元素,把小于 j-Li 的决策出队。
2.需要查询最优决策时,队头即为所求。
3.有一个新的决策需要加入队列时,在队尾检查 F[i-1,k]-Pi*k 的单调性,把无用决策从队尾直接出队,最后把新决策加入队列。
在本题具体来说,当内循环开始时(j==Si),建立一个空的单调队列,把(max(Si-Li,0),Si-1)中的决策依次加入候选集合(执行操作 3)。对于每个 (j=Si~k),先在队头检查决策合法性(操作 1),然后取队头为最优决策(操作 2)进行状态转移。因为每个决策至多入队,出队一次,故转移的时间复杂队均弹 (O(1))。整个算法的时间复杂度为 (O(NM))。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
using namespace std;
int read()
{
	int x=0,w=1;char ch=getchar();
	while(ch>'9'||ch<'0') {if(ch=='-')w=-1;ch=getchar();}
	while(ch>='0'&&ch<='9') x=(x<<3)+(x<<1)+ch-'0',ch=getchar();
	return x*w;
}
int dp[110][16010];
int team[16010];
struct node{
int l,p,s;
}f[110];
int cmp(node p,node q)
{
	return p.s<q.s;
}
int main()
{
	int n=read(),k=read();
	for(int i=1;i<=k;i++)
	{
		f[i].l=read();f[i].p=read();f[i].s=read();
	}
	sort(f+1,f+1+k,cmp);
	for(int i=1;i<=k;i++)
	{
		int l=1,r=0;
		for(int p=max(0,f[i].s-f[i].l);p<f[i].s;p++)
		{
			while(l<=r&&dp[i-1][team[r]]-f[i].p*team[r]<=dp[i-1][p]-f[i].p*p)
			r--;
			team[++r]=p;
		}
		for(int j=1;j<=n;j++)
		{
			dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
			if(j>=f[i].s)
			{
				while(l<=r&&team[l]<j-f[i].l) l++;
				if(l<=r)
				dp[i][j]=max(dp[i][j],dp[i-1][team[l]]+f[i].p*(j-team[l]));
			}
		}
	}
	cout<<dp[k][n];
}