POJ 1821 Fence 【DP动态规划】

POJ 1821 Fence 【DP动态规划】http://poj.org/problem?id=1821

Fence Time Limit: 1000MS   Memory Limit: 30000K Total Submissions: 3569   Accepted: 1083 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 Hint Explanation of the sample:  the worker 1 paints the interval [1, 2];  the worker 2 paints the interval [3, 4];  the worker 3 paints the interval [5, 7];  the worker 4 does not paint any plank  Source Romania OI 2002

[Submit]   [Go Back]   [Status]   [Discuss]

【题意】连续的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即可

【代码如下】

#include<stdio.h>
#include<iostream>
#include<math.h>
#include<string.h>
#include<iomanip>
#include<limits.h>
#include<stdlib.h>
#include<fstream>
#include<sstream>
//BASIC
#include<ctype.h>
#include<time.h>
#include<assert.h>
#include<bitset>
#include<cassert>
#include<complex>
//OTHER
#include<algorithm>
#include<deque>
#include<functional>
#include<iterator>
#include<vector>
#include<list>
#include<map>
#include<memory>
#include<numeric>
#include<queue>
#include<set>
#include<stack>
#include<utility>
//STL
using namespace std;

int n,k;
int dp[110][16010];
struct hehe{
    int L,P,S;
    bool operator < (const hehe &a) const{
        return a.S > S;
    }
}w[110];

int F()
{
    int ans = 0;
    int q[16010];
    for(int i = 1;i <= k;i++)
    {
        int st = 1,ed = 0;
        for(int j = 0;j < w[i].S;j++)
            dp[i][j] = dp[i-1][j];
        int tmp = max(w[i].S-w[i].L,0);
        for(int j = tmp;j < w[i].S;j++)
        {
            while(st<=ed && dp[i-1][q[ed]]-q[ed]*w[i].P <= dp[i-1][j]-j*w[i].P)
            {
                --ed;
            }
            q[++ed] = j;
        }
        for(int j = w[i].S;j <= n;j++)
        {
            while(st<=ed && q[st]<j-w[i].L) ++st;
            dp[i][j] = max(dp[i-1][j],dp[i][j-1]);
            if(st<=ed)
            {
                dp[i][j] = max(dp[i][j],dp[i-1][q[st]]+(j-q[st])*w[i].P);
            }
        }
    }
    return dp[k][n];
}

int main()
{
    while(~scanf("%d %d",&n,&k))
    {
        for(int i = 1;i <= k;i++){
            scanf("%d %d %d",&w[i].L,&w[i].P,&w[i].S);
        }
        sort(w+1,w+k+1);
        printf("%d\n",F());
    }
    return 0;
}