【算法入门】单调队列优化动态规划:[RomaniaOI2002]Fence

Problem

Description
A team of k (1 <= K <= 100) workers should paint a fence which contains N (1 <= N <= 16 000) planks numbered from 1 to N from left to right. Each worker i (1 <= i <= K) should sit in front of the plank Si and he may paint only a compact interval (this means that the planks from the interval should be consecutive). This interval should contain the Si plank. Also a worker should not paint more than Li planks and for each painted plank he should receive Pi $ (1 <= Pi <= 10 000). A plank should be painted by no more than one worker. All the numbers Si should be distinct.
Being the team’s leader you want to determine for each worker the interval that he should paint, knowing that the total income should be maximal. The total income represents the sum of the workers personal income.
Write a program that determines the total maximal income obtained by the K workers.
Input
The input contains:
Input
N K
L1 P1 S1
L2 P2 S2
…
LK PK SK
Semnification
N -the number of the planks; K ? the number of the workers
Li -the maximal number of planks that can be painted by worker i
Pi -the sum received by worker i for a painted plank
Si -the plank in front of which sits the worker i
Output
The output contains a single integer, the total maximal income.
Sample Input
8 4
3 2 2
3 2 3
3 3 5
1 1 7
Sample Output
17

---

Solution

• 拿到这道题以后，对si排序是一定的。这样才能保证算法的有序性。
• 对于这道题，考虑最简单的DP，设$f[i][j]$为前i个木匠，粉刷到第j块木板的最大收益。
• $①$当第$i$个木匠一块也不刷时：$f[i][j]=f[i-1][j]$
  $②$当第$i$个木匠不粉刷第j块时：$f[i][j]=f[i][j-1]$
  $③$第$i$块木匠粉刷第$j$块时，从第$k+1$块粉刷到$j$：
  此时要满足位置关系：$k+1\le Si\le j$；也要满足长度关系：$j-k\le L$。
  则方程：$f[i][j]=min(f[i-1][k]+(j-k)\ast pi)(j-Li\le k\le Si-1,j\ge si）$
• 时间复杂度：$O(N^{2}K)$
• 我们考虑对情况$③$进行优化
• $f[i][j]=min(f[i-1][k]+(j-k)\ast pi)$
  $\to f[i][j]=min(f[i-1][k]+j\ast pi-k\ast pi)$
  $\to f[i][j]=j\ast pi+min(f[i-1][k]-k\ast pi)(此时i，j可视为常量)$
  $此时满足(j-Li\le k\le Si-1,j\ge si)$
• 对于每一个$k$，我们发现其下界$j-Li$是随着j的增大而增大，而上界$Si-1$是不变的。
  此时，每一个$k$都对应着一个决策的值；并且，当当前的$j$舍弃了某个$k$以后，后面的$j$同样用不到该决策$k$。因此，我们可以用一个降序的单调队列来维护这一个决策的最优值。
• 对于这道题具体的做法是：
  $Step1$：将所有的决策塞到单调队列中并保持决策的单调性。
  $Step2$：在枚举j时将不合法的队头删去。
  $Step3$：在队列不为空时取队头进行状态转移。
• 代码如下：

#include
#include
#include
#include
using namespace std;
struct node{int l,p,s;};
node a[200];
int N,K,t,h;
int L[200],P[200],S[200],f[200][50000],q[50000];
inline bool cmp(node a,node b)
{
	if (a.s<b.s) return true;
	return false;
}
#define val(i,k) (f[i-1][k]-k*P[i])
int main(void)
{
	cin>>N>>K;
	for (int i=1;i<=K;++i)
	    cin>>a[i].l>>a[i].p>>a[i].s;
	sort(a+1,a+K+1,cmp);
	//按si降序排序 
	for (int i=1;i<=K;++i)
	    L[i]=a[i].l,P[i]=a[i].p,S[i]=a[i].s;
	//方便调用 
	    
	for (int i=1;i<=K;++i)
	{
		for (int j=max(0,S[i]-L[i]);j<=S[i]-1;++j)
		{
			while (h<=t && val(i,j)>=val(i,q[t])) --t;
			q[++t]=j;
		}
		//将所有决策进队 
		
		for (int j=1;j<=N;++j)
		{
			f[i][j]=max(f[i-1][j],f[i][j-1]);
			//第1,2种情况的状态转移 
			
			if (j<S[i]) continue;
			
			while (h<=t && q[h]<j-L[i]) h++;
			//排除非法状态 
			if (h<=t) f[i][j]=max(f[i][j],f[i-1][q[h]]+(j-q[h])*P[i]);
			//第3种情况的状态转移 
		}
	}
	cout<<f[K][N]<<endl;
	return 0; 
} 

最后再对单调队列优化的情况进行一些总结：
状态转移方程形如：$$f[i]=min(f[j]+val(i,j),L(i)\le j\le R(i)$$
其中，$j$的上下界变化具有单调性；多项式$val(i,j)$中的每一个单项式只能与$i$个$j$中的一项有关，不能同时包含$i$和$j$的乘积项。
这就是单调队列优化。
本文若有疏漏或错误之处，欢迎读者指正。