POJ1821 Fence --- 单调队列 + DP

关键即：

dp[i][j]=max(dp[i-1][j],dp[i][j-1],dp[i-1][k]+a[i].p*(j-k))//第三种是第i个人刷k+1到j
x[i]<=k<=a[i].s-1    a[i].s<=j<=y[i]

这题跟hdu-3401很像，构成单调队列的方式就是把第三种情况dp[i-1][k]+(j-k)*p化简成-k*p+j*p;

然后用队列维护的是从大到小的第i名工人刷墙收益，保存的是刷到第几面墙，则最后最大的收益就是队首。循环完了最后加上j*p时，要减去队首的位置，即j-st[be]

还需注意的是，这名工人的值需要一直延伸到最后，要考虑没有把墙涂满和用到所有工人的情况(样例)，

翻译过来就是第i名工人刷到第j面墙的最大收益(刷到不代表刷过)

//#include<bits/stdc++.h>
#include<iostream>
#include<stack>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<cstring>
#define mem(a) memset(a,0,sizeof(a))
#define ll long long
#define mp make_pair
#define pb push_back
#define inf 0x3f3f3f3f
using namespace std;
const int N=16000+5;
int n,maxp,k;
int l[N],p[N],s[N],dp[N][N],x[N],y[N],st[N];
struct node
{
    int l,p,s;
}a[150];
int cmp(node a,node b)
{
    return a.s<b.s;
}
void solve()
{
   sort(a+1,a+k+1,cmp);
   for(int i=1;i<=k;i++)
   {
       x[i]=max(0,a[i].s-a[i].l);  //左右边界
       y[i]=min(n,a[i].s+a[i].l-1);
   }
   for(int i=1;i<=k;i++)
   {
      for(int j=0;j<=y[i];j++)
        dp[i][j]=dp[i-1][j];
      int be=1,ed=1;
      for(int j=x[i];j<a[i].s;j++)
      {
          while(be<ed&&dp[i-1][j]-j*a[i].p>=dp[i-1][st[ed]]-st[ed]*a[i].p) ed--;
          st[++ed]=j;
      }
      for(int j=a[i].s;j<=y[i];j++)
      {
          while(be<ed&&j-st[be]>a[i].l) be++;
          dp[i][j]=max(dp[i][j-1],dp[i-1][j]);
          dp[i][j]=max(dp[i][j],dp[i-1][st[be]]+(j-st[be])*a[i].p);
      }
      for(int j=y[i]+1;j<=n;j++)
          dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
   }
   int ans=0;
   for(int i=1;i<=n;i++)
        ans=max(ans,dp[k][i]);
   printf("%d
",ans);
}
int main()
{
    scanf("%d%d",&n,&k);
    for(int i=1;i<=k;i++)
       scanf("%d%d%d",&a[i].l,&a[i].p,&a[i].s);
    solve();

    return 0;
}
/*
dp[i][j]=max{dp[i-1][j],dp[i][j-1],dp[i-1][k]+(j-k)*p[i]}

*/