POJ 1821 Fence

題意：連續的N塊木板，有K個粉刷匠，分別坐在第Si塊木板前，每個粉刷匠不能移動位置，且最多能粉刷連續的Li塊木板（必須包括Si或者不要該粉刷匠），每個粉刷匠粉刷一塊木板可以得Pi塊錢，求總共的最大利益。

題解：dp[i][j]代表前i個粉刷匠粉刷完成至多前j個木板的最大利益，狀態轉移有三種：

1、不需要第i個粉刷匠，即前i-1個粉刷匠完成前j個木板的工作：dp[i][j]=dp[i-1][j]

2、不需要粉刷第j塊木板，即前i個粉刷匠完成前j-1個木板的工作：dp[i][j]=dp[i][j-1]

3、前i-1個粉刷匠粉刷到了第k塊木板，然後第i個粉刷匠從第k+1開始一直粉刷到第j個木板：dp[i][j]=max(dp[i-1][k]+p[i]*(j-k))

前兩種直接轉移即可，第三種必須要用些優化才能節約時間dp[i-1][k]+p[i]*(j-k)=dp[i-1][k]-p[i]*k+p[i]*j，其中p[i]*j對固定dp[i][j]是固定的，即dp[i-1][k]-p[i]*k越大越好，所以可以用優先隊列將所有能夠通過第三種方式更新dp[i][j]儲存起來，能夠更新需要滿足兩個條件k<Si且k+Li>=j，所以可以首先將[Si-Li，Si-1]區間的值預處理出來，並在每次選取優先隊列中元素時判斷它是否滿足k+Li>=j即可（如果不滿足，因爲j是遞增的，它以後也不會滿足，所以可以直接pop掉）

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
struct Data
{
    int val,pos;
    bool operator<(const Data &ne)const
    {
        if(val!=ne.val)
            return val<ne.val;
        else
            return pos>ne.pos;
    }
    Data(){}
    Data(int _val,int _pos){val=_val;pos=_pos;}
}temp[16002];
struct People
{
    int l,p,s;
    bool operator<(const People &ne)const
    {
        return s<ne.s;
    }
}po[102];
int dp[102][16002];
int main()
{
    int n,m,top;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        for(int i=1;i<=m;i++)
            scanf("%d%d%d",&po[i].l,&po[i].p,&po[i].s);
        po[m+1].p=0;
        sort(po+1,po+m+1);
        memset(dp,0,sizeof(dp));
        for(int i=1;i<=m;i++)
        {
            int ll=po[i].l,pp=po[i].p,ss=po[i].s,pr=po[i+1].p;
            priority_queue<Data> Q;
            for(int j=max(0,ss-ll);j<ss;j++)
                Q.push(Data(dp[i-1][j]-j*pp,j));
            for(int j=1;j<=n;j++)
            {
                dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
                if(j<ss||ss+ll-1<j)
                    continue;
                while(!Q.empty()&&Q.top().pos+ll<j)
                    Q.pop();
                if(Q.empty())
                    continue;
                dp[i][j]=max(dp[i][j],Q.top().val+pp*j);
            }
        }
        printf("%d\n",dp[m][n]);
    }
    return 0;
}