Fence

最新推荐文章于 2024-03-29 16:51:25 发布

MIsike

最新推荐文章于 2024-03-29 16:51:25 发布

阅读量859

点赞数

分类专栏： dp ACM练习题

本文链接：https://blog.csdn.net/domacles0124/article/details/10190051

版权

ACM练习题同时被 2 个专栏收录

95 篇文章 0 订阅

订阅专栏

51 篇文章 0 订阅

订阅专栏

Fence

Time Limit: 1000MS		Memory Limit: 30000K

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

Sample Output

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

/**

题目意思就是说给你一段墙，有K个粉刷工，每个粉刷工站在一个位置，且每个粉刷工只能刷L连续长度的墙，
且要包括他所在的位置，而且每个粉刷工刷一个单位的墙的价格也不一样，问怎么刷能达到最大价钱.

先以P为关键字对工人进行排序，使这个顺序作为动态规划的阶段。

定义DP[I]代表粉刷前I个栅栏最大价值，有如下状态转移方程：
DP[I]=Max{DP[J]+Len*Cost}

顺序枚举工人I，递减的枚举右边界J，然后定义一个变量K，初始时K=P[I]，代表第I个工人粉刷的左边界。
显然DP[J]:=Max{DP[K-1]+（J-K+1）*Cost[I]}

复杂度：O（K*N*N），需要优化~~可题意优化~~

/**有单调队列优化：
  *http://www.abandonzhang.com/archives/554
**/

#include <map>
#include <set>
#include <list>
#include <queue>
#include <stack>
#include <cmath>
#include <ctime>
#include <vector>
#include <bitset>
#include <cstdio>
#include <string>
#include <numeric>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#include <functional>
using namespace std;
typedef long long  ll;
typedef unsigned long long ull;

int dx[4]= {-1,1,0,0};
int dy[4]= {0,0,-1,1}; //up down left right
bool inmap(int x,int y,int n,int m)
{
    if(x<1||x>n||y<1||y>m)return false;
    return true;
}
int hashmap(int x,int y,int m)
{
    return (x-1)*m+y;
}

#define eps 1e-8
#define inf 0x7fffffff
#define debug puts("BUG")
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
#define read freopen("in.txt","r",stdin)
#define write freopen("out.txt","w",stdout)
#define maxn 111

int M,N;
long long dp[20000];
long long ans;
struct Node
{
    long long L,P,S;
    long long st,en;
} a[maxn];
bool cmp(Node a,Node b)
{
    return a.S<b.S;
}

void DP()
{
    for(int i=0; i<N; i++)
    {
        int k=a[i].S;
        for(int j=a[i].S+a[i].L-1; j>=a[i].S; j--)
        {
            if(j<=M&&j-a[i].L<=0)
                dp[j]=max(dp[j],j*a[i].P);
            else if(j<=M)
                dp[j]=max(dp[j],dp[k-1]+(j-k+1)*a[i].P);
            /**这里是优化，k的值要随着最优区域而变化**/
//当递减循环到J'的时，设T=J'-Len[I]+1，当((K-1)-(T-1))*Cost[I]> DP[K-1] - DP[T-1]时，K:=T，否则K不变
            if(j-a[i].L>0&&a[i].P*(a[i].L-(j-k))>dp[k-1]-dp[k-1-(a[i].L-(j-k))])
                k=j-a[i].L;
        }
        for(int j=a[i].S+a[i].L; j<=M; j++)
            dp[j]=max(dp[j],dp[a[i].S+a[i].L-1]);
    }
    ans=dp[M];
}

int main()
{
    scanf("%d%d",&M,&N);
    for(int i=0; i<N; i++)
        scanf("%lld%lld%lld",&a[i].L,&a[i].P,&a[i].S);

    sort(a,a+N,cmp);

    DP();

    printf("%lld\n",ans);
    return 0;
}