POJ1821-Fence

Fence

Time Limit: 1000MS Memory Limit: 30000KTotal Submissions: 4837 Accepted: 1528

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 43 2 23 2 33 3 51 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

题意：连续的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 <iostream>#include <cstdio>#include <string>#include <cstring>#include <algorithm>#include <cmath>#include <queue>#include <vector>#include <set>#include <stack>#include <map>#include <climits>using namespace std;#define LL long longconst int INF=0x3f3f3f3f;int dp[110][16009];int q[16009];struct node{    int l,p,s;}x[110];int cmp(node a,node b){    return a.s<b.s;}int main(){    int n,k;    while(~scanf("%d %d",&n,&k))    {        for(int i=1;i<=k;i++) scanf("%d %d %d",&x[i].l,&x[i].p,&x[i].s);        sort(x+1,x+k+1,cmp);        int head,rear;        memset(dp,0,sizeof(dp));        for(int i=1;i<=k;i++)        {            head=0;rear=1;            q[0]=max(x[i].s-x[i].l,0);            for(int j=1;j<=n;j++)            {                dp[i][j]=max(dp[i][j-1],dp[i-1][j]);                if(j>=x[i].s+x[i].l) continue;                while(head<rear&&q[head]+x[i].l<j) head++;                if(j<x[i].s)                {                    int temp=dp[i-1][j]-j*x[i].p;                    while(head<rear&&dp[i-1][q[rear-1]]-q[rear-1]*x[i].p<temp) rear--;                    q[rear++]=j;                    continue;                }                dp[i][j]=max(dp[i][j],dp[i-1][q[head]]+x[i].p*(j-q[head]));            }        }        printf("%d\n",dp[k][n]);    }    return 0;}