POJ - 1821 Fence 单调队列优化DP

Fence

Time Limit: 1000MS		Memory Limit: 30000K
Total Submissions: 5933		Accepted: 1900

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

---

题目

现在有n个地板需要画，同时有k个工人分别坐在S[i]位置上。

每个工人只能画他周围最多L[i]个位置，即如果画必须画上S[i]位置,每画一个可得到P[i]的金钱。

现在要求总的最大金钱。

---

题解

直观的想法

dp[i][j] 表示前i个工人画到第j个地板所得到的最大金钱。

那么dp[i][j] = max(dp[i][j-1],dp[i-1][j]) 

(假设当前第i个工人不画第j个位置，那么dp[i][j] 就等于前i个工人画到第j-1个或者前i-1个工人画到第j个的最大值)

如果画上第j个位置

则dp[i][j] = max(dp[i-1][k]+(j-k)*P[i],dp[i][j])

k是枚举的上一个工人画到什么位置 

j-L[i]<=k<S[i] 上一个工人不能画到S[i] 因为第i个工人必须要画上S[i]的位置

S[i]<=j<S[i]+L[i]

于是可以写出O(n^2k)的dp

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
using namespace std;
typedef long long ll;
const int maxn = 2e4+10;
ll dp[105][maxn]; // dp[i][j] : 表示前i个工人画到第j个木板所获得的最大金钱数.
int n,k;
struct Person{
    int L,P,S;
    bool operator < (const Person &a) const {
        return S < a.S;
    }
}worker[105];
int main()
{
    while(~scanf("%d%d",&n,&k)) {
        for(int i=1;i<=k;i++) scanf("%d%d%d",&worker[i].L,&worker[i].P,&worker[i].S);
        sort(worker+1,worker+k+1);
        memset(dp,0,sizeof(dp));
        for(int i=1;i<=k;i++) {
            for(int j=1;j<=n;j++) {
                dp[i][j] = max(dp[i-1][j],dp[i][j-1]);
                if(j>=worker[i].S && j<worker[i].S+worker[i].L) {
                    for(int k=max(j-worker[i].L,0);k<worker[i].S;k++) {
                        dp[i][j] = max(dp[i-1][k]+(j-k)*worker[i].P,dp[i][j]);
                    }
                }
            }
        }
        printf("%lld\n",dp[k][n]);
    }
    return 0;
}

显然是超时的。

我们注意到

显然满足单调队列的性质。那么将公式转化成

单调队列维护一下 的最大值，然后注意一下 k 的范围

需要注意的是需要添加一个0值点到单调队列，因为有前面所有工人都没用画的情况。

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<deque>
using namespace std;
typedef long long ll;
const int maxn = 2e4+10;
ll dp[105][maxn]; // dp[i][j] : 表示前i个工人画到第j个木板所获得的最大金钱数.
int n,k;
deque<pair<int,ll> > qu;
struct Person{
    int L,P,S;
    bool operator < (const Person &a) const {
        return S < a.S;
    }
}worker[105];
int main()
{
    while(~scanf("%d%d",&n,&k)) {
        qu.clear();
        for(int i=1;i<=k;i++) scanf("%d%d%d",&worker[i].L,&worker[i].P,&worker[i].S);
        sort(worker+1,worker+k+1);
        memset(dp,0,sizeof(dp));
        for(int i=1;i<=k;i++) {
            qu.clear();
            qu.push_back(make_pair(0,0));
            for(int j=1;j<=n;j++) {
                dp[i][j] = max(dp[i-1][j],dp[i][j-1]);
                if(j < worker[i].S) {
                    while(!qu.empty() && qu.back().second < dp[i-1][j] - j * worker[i].P) qu.pop_back();
                    qu.push_back(make_pair(j,dp[i-1][j]-j*worker[i].P));
                }
                else {
                    while(!qu.empty() && qu.front().first+worker[i].L < j) qu.pop_front();
                    if(!qu.empty()) {
                        dp[i][j] = max(qu.front().second + j*worker[i].P,dp[i][j]);
                    }
                }
            }
        }
        printf("%lld\n",dp[k][n]);
    }
    return 0;
}

如果使用了数组模拟双端队列时间优化了不少

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<deque>
using namespace std;
typedef long long ll;
const int maxn = 2e4+10;
ll dp[105][maxn]; // dp[i][j] : 表示前i个工人画到第j个木板所获得的最大金钱数.
int n,k;
pair<int,ll> qu[maxn];
struct Person{
    int L,P,S;
    bool operator < (const Person &a) const {
        return S < a.S;
    }
}worker[105];
int main()
{
    while(~scanf("%d%d",&n,&k)) {
        for(int i=1;i<=k;i++) scanf("%d%d%d",&worker[i].L,&worker[i].P,&worker[i].S);
        sort(worker+1,worker+k+1);
        memset(dp,0,sizeof(dp));
        for(int i=1;i<=k;i++) {
            int h = 1,t = 0;
            qu[++t] = make_pair(0,0);
            for(int j=1;j<=n;j++) {
                dp[i][j] = max(dp[i-1][j],dp[i][j-1]);
                if(j < worker[i].S) {
                    while(h<=t && qu[t].second < dp[i-1][j] - j * worker[i].P) t--;
                    qu[++t] = make_pair(j,dp[i-1][j]-j*worker[i].P);
                }
                else {
                    while(h<=t && qu[h].first+worker[i].L < j) h++;
                    if(h<=t) {
                        dp[i][j] = max(qu[h].second + j*worker[i].P,dp[i][j]);
                    }
                }
            }
        }
        printf("%lld\n",dp[k][n]);
    }
    return 0;
}

以后还是尽量使用数组模拟吧。