EOJ:Museum Guards

Museum Guards

Time Limit: 5000MS		Memory Limit: 65536K
Total Submits: 38		Accepted: 17

Description

A museum has hired some guards and is trying to build a schedule for them. The museum would like to build a 24-hour schedule for the guards, such that:

• Each guard works during the same time intervals every day.
• Each guard works within his/her time windows of availability, which s/he specifies.
• Each guard works at most the amount of time s/he is able, which s/he also specifies.
• The guards can only shift (start or stop working) on half hour boundaries. (e.g. 04:00 or 04:30, but not 04:15).
• The guards are only scheduled for shifts if they are available to work at all times during those shifts. (e.g. if a guard‟s window of availability opens at 03:05, they cannot be scheduled at 03:00.)
• The minimum number of guards on duty at any time during the day is maximized. This improves security of the museum.

Write a program to help the museum staff determine the maximum number of guards that they can maintain at all times throughout a 24-hour day, given the constraints of the guards‟ availability. You may assume that guard exchanges are instantaneous. That is, if 2 guards leave and 2 other guards arrive at the same time, the museum is guarded by 2 guards through this exchange.

 

Input

There will be multiple test cases. Each test case begins with a line containing a single integer N (1 ≤ N ≤ 50), the number of guards available. There will then be N blocks of data, one for each guard.
Each block provides the preferences of one guard. A block begins with two integers, K (1 ≤ K ≤ 50) and M (1 ≤ M ≤ 1440), in that order; K is the number of time intervals specifying when the guard is available for work, and M is the maximum number of minutes s/he is able to work each day. The next K lines each contains the starting and ending time, in that order, of a time interval where the guard is available, separated by whitespace. These time intervals may overlap. The union of all K time intervals provides the complete set of times at which the guard is available.
A starting or ending time is formatted as HH:MM (00 ≤ HH ≤ 23, 00 ≤ MM ≤ 59). Midnight is represented by 00:00. When the ending time is smaller than the starting time, it means the guard is available for working past midnight. For example, the interval “23:00 03:00” means the guard is available from 11pm at night to 3am in the morning. If the starting and ending times are equal, then the guard is available for work during any time intervals throughout the day. The last test case is followed by a line with a single 0.

 

Output

For each test case, output a single integer, representing the minimum number of guards on duty at any given time during the day, using a schedule that maximizes this value. That is, output the largest integer k, such that there is a schedule where at any given moment, there are k guards on duty at the museum, assuming instantaneous exchanges specified above. Do not print any blank lines between answers.

 

Sample Input

3
1 540
00:00 00:00
3 480
08:00 10:00
09:00 12:00
13:00 19:00
1 420
17:00 00:00
5
1 720
18:00 12:00
1 1080
00:00 23:00
1 1080
00:00 20:00
1 1050
06:00 00:00
1 360
18:00 00:00
3
1 1440
00:00 00:00
1 720
00:00 12:15
1 720
12:05 00:15
0

 

Sample Output

1
2
1

 

Source

Southeastern USA 2009

原题地址：http://www.cn210.com/onlinejudge/problemshow.php?pro_id=236

__________________________________________________________________________________________________

题解：

这题我调了四天！

题目中说守卫只能在整点或者整半点的时候交换工作，这是一个很明显的暗示（可惜比赛当时没看出来）

将每个守卫看成点，一天二十四个小时，分成48个点，如果一个守卫能在某半个小时连线，就将其与该半个小时的点连条线。

再添加一个源点，与每个守卫连线，权值就是守卫总共能工作的时间，添加一个汇点，与每半个小时连线。

这样就是一个最大流问题，最大流有很多中解决方法，四天中有两天就是为了调那个ISAP算法……

但是仔细想想，会出现一个问题：

假设时间点到汇点的权值无穷大，如果守卫一能在00:30和1:00工作，守卫二也能在00:30和1:00工作，那么守卫一和守卫二在同时在00:30和守卫在00:30,守卫二在1:00工作的最大流是一样的，但题目要求使得一天二十四小时都有警卫工作。所以我们需要枚举时间点到汇点的权值，做N次最大流。

另外还有一个需要注意的地方，源点到守卫点的权值要设为T/30，而守卫点到时间点的权值为1。为了这个我调了一个晚上……如果权值设为分钟数，守卫点到时间点的权值为30的话，那么可能出现守卫在一个时间点工作小于30分钟的情况。

#include<stdio.h>
#include<memory.h>
#include<stdlib.h>
 #define maxn 102
 int d[maxn],g[maxn][maxn],f[maxn][maxn],pre[maxn],map[maxn][maxn],sum[maxn],current[maxn];
 int n,m,num,mm;
 struct node
{
    int x,y;
}seg[1000],time[1000];
 #define oo 0xfffffff
 int cmp(const void *a,const void *b)
{
    struct node *va=(struct node*)a;
    struct node *vb=(struct node*)b;
    return va->x-vb->x;
}
 void rev_bfs(int t)
{
    int queue[maxn],flag[maxn];
    int head,tail,i;
    memset(sum,0,sizeof(sum));
    for (i=0;i<=n+49;i++)
    {
        d[i]=n+49;
        sum[n+49]++;
    }
    sum[n+49]--;
    sum[0]++;
    d[t]=0;
    queue[1]=t;
    flag[t]=1;
    head=1;tail=1;
    memset(flag,0,sizeof(flag));
    while (head<=tail)
    {
        for (i=0;i<=n+49;i++)
            if (flag[i]==0&&g[i][queue[head]]>0)
            {
                queue[++tail]=i;
                d[i]=d[queue[head]]+1;
                sum[n+49]--;
                sum[d[i]]++;
                flag[i]=1;
            }
        head++;
    }
}
 void augment(int s,int t)
{
    int i,min;
    min=oo;
    for (i=t;i!=s;i=pre[i])
         if (g[pre[i]][i]<min)
            min=g[pre[i]][i];
    for (i=t;i!=s;i=pre[i])
    {
        g[pre[i]][i]-=min;;
        g[i][pre[i]]+=min;
        f[pre[i]][i]+=min;
        f[i][pre[i]]-=min;
    }
}
 int retreat(int *u,int s)
{
    int v,min;
    min=n+49;
    for (v=0;v<=n+49;v++)
        if (g[*u][v]>0&&d[v]<min)
            min=d[v];
    sum[d[*u]]--;
    if ((sum[d[*u]])==0&&d[*u]<=n+49) return 0;
    d[*u]=min+1;
    sum[d[*u]]++;
    current[*u]=0;
    if (*u!=s) *u=pre[*u];
    return 1;
}
 void ISAP(int s,int t)
{
    int u,v;
    rev_bfs(t);
    u=s;
    while (d[s]<n+50)
    { 
        for (v=current[u];v<=n+49;v++)                                                                            
            if (g[u][v]>0&&d[u]==d[v]+1)
                break;
        if (v<=n+49)
        {
            current[u]=v;
            pre[v]=u;
            u=v;
            if (u==t)
            {
                augment(s,t);
                u=s;
            }
        }
        else if (retreat(&u,s)==0) return;
    }
}
void init()
{
    int i,j,a,b,c,d,min,t,k,ans,max,st,en,temp;
    while (scanf("%d",&n)!=EOF&&n)
    {
        memset(map,0,sizeof(map));;
        for (i=1;i<=n;i++)
        {
            scanf("%d%d",&m,&t);
            map[48][i+48]=t/30;
            num=0;
            mm=0;
            for (j=1;j<=m;j++)
            {
                scanf("%d:%d %d:%d",&a,&b,&c,&d);
                if (a==c&&b==d)
                {
                    for (k=0;k<48;k++)
                        map[i+48][k]=1;
                    continue;
                }
                if (c==0&&d==0)
                {
                    num++;
                    seg[num].x=a*60+b;
                    seg[num].y=1440;
                }
                else if (a*60+b>c*60+d)
                {
                    num++;
                    seg[num].x=a*60+b;
                    seg[num].y=1440;
                    num++;
                    seg[num].x=0;
                    seg[num].y=c*60+d;
                }
                else
                {
                    num++;
                    seg[num].x=a*60+b;
                    seg[num].y=c*60+d;
                }
            }
            if (num==0) continue;
            qsort(seg+1,num,sizeof(seg[1]),cmp);
            st=seg[1].x;en=seg[1].y;
            seg[num+1].x=1500;seg[num+1].y=1600;
            for (j=2;j<=num+1;j++)
            {
                a=seg[j].x;
                b=seg[j].y;
                if (st<=a&&a<=en&&en<b)
                    en=b;
                else if (a>en)
                {
                    mm++;
                    time[mm].x=st;
                    time[mm].y=en;
                    st=a;
                    en=b;
                }
            }
            for (j=1;j<=mm;j++)
            {
                a=time[j].x/60;
                b=time[j].x-60*a;
                c=time[j].y/60;
                d=time[j].y-60*c;
                if (a==c)
                {
                    if (b==0&&d>=30)
                        map[i+48][a*2]=1;
                }
                else
                {
                    if (b>0&&b<=30) b=30;
                    if (b>30) 
                    {
                        a++;
                        b=0;
                    }
                    if (d<30) d=0;
                    if (d>30) d=30;
                    while (a!=c||b!=d)
                    {
                        map[i+48][a*2+b/30]=1;
                        b+=30;
                        if (b==60)
                        {
                            a++;
                            b=0;
                        }
                    }
                }
            }
        }
        max=oo;
        for (j=0;j<48;j++)
        {
            temp=0;
            for (k=49;k<n+49;k++)
                if (map[k][j]>0) temp++;
            if (temp<max)
                max=temp;
        }
        ans=0;
        for (j=1;j<=max;j++)
        {
            memset(g,0,sizeof(g));
            memset(f,0,sizeof(f));
            memset(current,0,sizeof(current));
            for (i=0;i<=49+n;i++)
                for (k=0;k<=49+n;k++)
                    g[i][k]=map[i][k];
            for (i=0;i<48;i++)
                g[i][n+49]=j;
            ISAP(48,n+49);
            min=oo;
            for (i=0;i<48;i++)
                if (f[i][n+49]<min)
                    min=f[i][n+49];
            if (min>ans) ans=min;
        }
        printf("%d\n",ans);
    }
}
int main()
{
    freopen("a.txt","r",stdin);
    //freopen("b.txt","w",stdout);
    init();
    return 0;
}