【POJ1821】Fence

单调队列优化dp

我们将每个人的s值排序，这样我们就能保证当前这个人刷的木板一定在上一个人之后，我们就能进行线型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]木板，由题意得k+1≤S_i≤j并且j-k≤L_i,于是存在状态转移方程

在dp过程中，我们假定外层变量i为定值，当j增大时，不难发现k的取值范围上界不变，下界变大。我们不妨比较一下两个决策k1,k2，假设k1<k2≤S_i-1

因为k2的位置靠后，所以k1最更早的被排除，如果此时满足

说明k2不仅更优，而且它存活的时间更长，我们就可以将k1排除。

因此，我们可以建立一个单调队列，存储决策允许集合并且保证决策点k单调递增，数值f[i-1][k]-Pi*k单调递减的序列。每次我们取出队头决策（最优）进行转移即可。

所以，我们就可以设计dp解决问题了

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
typedef long long ll;
inline int read() {
    int ret=0;
    int op=1;
    char c=getchar();
    while(c<'0'||c>'9') {if(c=='-') op=-1; c=getchar();}
    while(c<='9'&&c>='0') ret=ret*10+c-'0',c=getchar();
    return ret*op;
}
struct node {
    int l,s,p;
    bool operator <(const node &x) const {
        return s<x.s;
    }
}a[110];
int n,m,f[110][16010];
int q[16010],l,r;
inline int calc(int i,int k) {
    return f[i-1][k]-a[i].p*k;
}
int main() {
    n=read(); m=read();
    for(int i=1;i<=m;i++) {
        a[i].l=read();
        a[i].p=read();
        a[i].s=read();
    }
    sort(a+1,a+m+1);
    for(int i=1;i<=m;i++) {
        l=1,r=0;
        for(int k=max(0,a[i].s-a[i].l);k<=a[i].s-1;k++) {
            while(l<=r&&calc(i,k)>=calc(i,q[r])) r--;
            q[++r]=k;
        }
        for(int j=1;j<=n;j++) {
            f[i][j]=max(f[i-1][j],f[i][j-1]);
            if(j>=a[i].s) {
                while(l<=r&&j-a[i].l>q[l]) l++;
                if(l<=r) f[i][j]=max(f[i][j],calc(i,q[l])+j*a[i].p);
            }
        }
    }
    printf("%d
",f[m][n]);
    return 0;
}