poj 3762 The Bonus Salary! 需离散化

最新推荐文章于 2017-03-13 20:54:08 发布

ACBOY、

最新推荐文章于 2017-03-13 20:54:08 发布

阅读量1.2k

点赞数

分类专栏：图论

本文链接：https://blog.csdn.net/crescent__moon/article/details/24551469

版权

图论专栏收录该内容

168 篇文章 0 订阅

订阅专栏

点击打开链接

The Bonus Salary!

Time Limit: 2000MS		Memory Limit: 65536K
Total Submissions: 2299		Accepted: 601

Description

In order to encourage employees' productivity, ACM Company has made a new policy. At the beginning of a period, they give a list of tasks to each employee. In this list, each task is assigned a "productivity score". After the first K days, the employee who gets the highest score will be awarded bonus salary.

Due to the difficulty of tasks, for task i-th:

It must be done from hh_L_i : mm_L_i : ss_L_i to hh_R_i : mm_R_i : ss_R_i.
This range of time is estimated very strictly so that anyone must use all of this time to finish the task.

Moreover, at a moment, each employee can only do at most one task. And as soon as he finishes a task, he can start doing another one immediately.

XYY is very hard-working. Unfortunately, he's never got the award. Thus, he asks you for some optimal strategy. That means, with a given list of tasks, which tasks he should do in the first K days to maximize the total productivity score. Notice that one task can be done at most once.

Input

The first line contains 2 integers N and K (1 ≤ N ≤ 2000, 0 ≤ K ≤ 100), indicating the number of tasks and days respectively. This is followed by N lines; each line has the following format:

hh_L_i:mm_L_i:ss_L_i hh_R_i:mm_R_i:ss_R_i w

Which means, the i-th task must be done from hh_L_i : mm_L_i : ss_L_i to hh_R_i : mm_R_i : ss_R_i and its productivity score is w. (0 ≤hh_L_i, hh_R_i ≤ 23, 0 ≤mm_L_i, mm_R_i, ss_L_i, ss_R_i ≤ 59, 1 ≤ w ≤ 10000). We use exactly 2 digits (possibly with a leading zero) to represent hh, mm and ss. It is guaranteed that the moment hh_R_i : mm_R_i : ss_R_i is strictly later than hh_L_i : mm_L_i : ss_L_i.　

Output

The output only contains a nonnegative integer --- the maximum total productivity score.

Sample Input

5 2
09:00:00 09:30:00 2
09:40:00 10:00:00 3
09:29:00 09:59:00 10
09:30:00 23:59:59 4
07:00:00 09:31:00 3

Sample Output

Hint

The optimal strategy is:
Day1: Task1, Task 4
Day2: Task 3
The total productivity score is 2 + 4 + 10 = 16.

Source

有n个任务，每个任务都有一个区间，每完成一个任务就会得到一定的分数，每次只能做一个任务，而且要求做满此任务的整个时间段，给你k天的时间，问最多能够得到多少分。

首先时间太杂，因此需要离散化一下，将所有的时间点按照从小到大排序，然后每个时间点和它后面的时间点相连，容量为inf，费用为0.之所以这样连，是因为如果你要做这个时间点上的任务，那你就走时间段那条边，但如果你不做这个时间点上的任务，为了确保你还可以沿着时间继续走下去，所以建了一条容量为无穷费用为零的边。

将每个任务的开始和结束相连，容量为1，费用为负的分数，因为任务只能做一次，且要求最大分数，所以分数为负。

源点与第一个时间点相连，容量为k，费用为0.表示一共有k天。

//2404K	1266MS
#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>
#include<cstdio>
using namespace std;
const int MAXN=100000;
const int inf=10000000;
int pre[MAXN];          // pre[v] = k：在增广路上，到达点v的边的编号为k
int dis[MAXN];          // dis[u] = d：从起点s到点u的路径长为d
int vis[MAXN];         // inq[u]：点u是否在队列中
int path[MAXN];
int head[MAXN];
int NE,tot,ans,max_flow;
int z[90000];
int vist[MAXN];
struct T
{
    int s,e,w;
} time[2207];
struct node
{
    int u,v,cap,cost,next;
} Edge[MAXN];
void addEdge(int u,int v,int cap,int cost)
{
    Edge[NE].u=u;
    Edge[NE].v=v;
    Edge[NE].cap=cap;
    Edge[NE].cost=cost;
    Edge[NE].next=head[u];
    head[u]=NE++;
    Edge[NE].v=u;
    Edge[NE].u=v;
    Edge[NE].cap=0;
    Edge[NE].cost=-cost;
    Edge[NE].next=head[v];
    head[v]=NE++;
}
int SPFA(int s,int t)                   //  源点为0，汇点为sink。
{
    int i;
    for(i=s; i<=t; i++) dis[i]=inf;
    memset(vis,0,sizeof(vis));
    memset(pre,-1,sizeof(pre));
    dis[s] = 0;
    queue<int>q;
    q.push(s);
    vis[s] =1;
    while(!q.empty())        //  这里最好用队列，有广搜的意思，堆栈像深搜。
    {
        int u =q.front();
        q.pop();
        for(i=head[u]; i!=-1; i=Edge[i].next)
        {
            int v=Edge[i].v;
            if(Edge[i].cap >0&& dis[v]>dis[u]+Edge[i].cost)
            {
                dis[v] = dis[u] + Edge[i].cost;
                pre[v] = u;
                path[v]=i;
                if(!vis[v])
                {
                    vis[v] =1;
                    q.push(v);
                }
            }
        }
        vis[u] =0;
    }
    if(pre[t]==-1)
        return 0;
    return 1;
}
void end(int s,int t)
{
    int u, sum = inf;
    for(u=t; u!=s; u=pre[u])
    {
        sum = min(sum,Edge[path[u]].cap);
    }
    max_flow+=sum;                          //记录最大流
    for(u = t; u != s; u=pre[u])
    {
        Edge[path[u]].cap -= sum;
        Edge[path[u]^1].cap += sum;
        ans += sum*Edge[path[u]].cost;     //  cost记录的为单位流量费用，必须得乘以流量。
    }
}
int main()
{
    int n,k,s,t;
    scanf("%d%d",&n,&k);
    memset(head,-1,sizeof(head));
    memset(z,0,sizeof(z));
    NE=ans=max_flow=s=0;
    int num=0,h,m,ss;
    for(int i=0; i<n; i++)
    {
        scanf("%d:%d:%d",&h,&m,&ss);
        time[i].s=h*3600+m*60+ss;
        z[num++]=time[i].s;
        scanf("%d:%d:%d",&h,&m,&ss);
        time[i].e=h*3600+m*60+ss;
        z[num++]=time[i].e;
        scanf("%d",&time[i].w);
    }
    sort(z,z+num);
    int e=1;
    memset(vist,0,sizeof(vist));
    for(int i=0; i<num; i++)
        if(!vist[z[i]])vist[z[i]]=e++;
    for(int i=1; i<e-1; i++)
        addEdge(i,i+1,inf,0);
    for(int i=0; i<n; i++)
        addEdge(vist[time[i].s],vist[time[i].e],1,-time[i].w);
    addEdge(0,1,k,0);
    t=e-1;
    while(SPFA(s,t))
    {
        end(s,t);
    }
    printf("%d\n",-ans);
    return 0;
}