Stall Reservations(POJ 3190 贪心+优先队列)

Stall Reservations

Time Limit: 1000MS   Memory Limit: 65536K
Total Submissions: 4434   Accepted: 1588   Special Judge

Description

Oh those picky N (1 <= N <= 50,000) cows! They are so picky that each one will only be milked over some precise time interval A..B (1 <= A <= B <= 1,000,000), which includes both times A and B. Obviously, FJ must create a reservation system to determine which stall each cow can be assigned for her milking time. Of course, no cow will share such a private moment with other cows.

Help FJ by determining:

  • The minimum number of stalls required in the barn so that each cow can have her private milking period
  • An assignment of cows to these stalls over time

Many answers are correct for each test dataset; a program will grade your answer.

Input

Line 1: A single integer, N

Lines 2..N+1: Line i+1 describes cow i‘s milking interval with two space-separated integers.

Output

Line 1: The minimum number of stalls the barn must have.

Lines 2..N+1: Line i+1 describes the stall to which cow i will be assigned for her milking period.

Sample Input

5
1 10
2 4
3 6
5 8
4 7

Sample Output

4
1
2
3
2
4

Hint

Explanation of the sample:

Here‘s a graphical schedule for this output:

Time     1  2  3  4  5  6  7  8  9 10
Stall 1 c1>>>>>>>>>>>>>>>>>>>>>>>>>>>
Stall 2 .. c2>>>>>> c4>>>>>>>>> .. ..
Stall 3 .. .. c3>>>>>>>>> .. .. .. ..
Stall 4 .. .. .. c5>>>>>>>>> .. .. ..

Other outputs using the same number of stalls are possible.

这个题是说一些奶牛要在指定的时间内挤牛奶,而一个机器只能同时对一个奶牛工作。给你每头奶牛的指定时间的区间,问你最小需要多少机器。

先按奶牛要求的时间起始点进行从小到大排序,然后维护一个优先队列,里面以已经开始挤奶的奶牛的结束时间早为优先。然后每次只需要检查当前是否有奶牛的挤奶工作已经完成的机器即可,若有,则换那台机器进行工作。若没有,则加一台新的机器。

 1 #include <cstdio>
 2 #include <cstring>
 3 #include <iostream>
 4 #include <algorithm>
 5 #include <queue>
 6 using namespace std;
 7 const int maxn=60000;
 8 int n,use[maxn];
 9 struct Node
10 {
11     int l;
12     int r;
13     int pos;
14     bool operator <(const Node &a)const
15     {
16     if(r==a.r)
17         return l>a.l;
18     return r>a.r;
19     }
20 }a[maxn];
21 priority_queue<Node> q;
22 bool cmp(Node a,Node b)
23 {
24     if(a.l==b.l)
25     return a.r<b.r;
26     return a.l<b.l;
27 }
28 int main()
29 {
30     while(scanf("%d",&n)!=EOF)
31     {
32     for(int i=0;i<n;i++)
33     {
34         scanf("%d%d",&a[i].l,&a[i].r);
35         a[i].pos=i;
36     }
37     sort(a,a+n,cmp);
38     q.push(a[0]);
39     int now=0,ans=1;
40     use[a[0].pos]=1;
41     for(int i=1;i<n;i++)
42     {
43         if(!q.empty()&&q.top().r<a[i].l)
44         {
45         use[a[i].pos]=use[q.top().pos];
46         q.pop();
47         }
48         else
49         {
50         ans++;
51         use[a[i].pos]=ans;
52         }
53         q.push(a[i]);
54     }
55     printf("%d\n",ans);
56     for(int i=0;i<n;i++)
57         printf("%d\n",use[i]);
58     while(!q.empty())
59         q.pop();
60     }
61     return 0;
62 }    

TLE CODE:

 1 #include <iostream>
 2 #include <cstdio>
 3 #include <algorithm>
 4 #include <cstring>
 5 using namespace std;
 6 struct node
 7 {
 8     int x1,x2;
 9     int num;
10 }a[50000+10];
11 bool cmp(node a,node b)
12 {
13     if(a.x1==b.x1)
14         return a.x2<b.x2;
15     return a.x1<b.x1;
16 }
17 bool vis[50000+10];
18 int pos[50000+10];
19 int n;
20 int search(int m)
21 {
22     int l=0,r=n-1,mid,k=-1;
23     while(l<=r)
24     {
25         mid=(l+r)/2;
26         if(a[mid].x1>=m)
27         {
28
29             k=mid;
30             r=mid-1;
31         }
32         else
33             l=mid+1;
34     }
35     return k;
36 }
37 int main()
38 {
39     int i,j;
40     freopen("in.txt","r",stdin);
41     while(scanf("%d",&n)!=EOF)
42     {
43         int count=0;
44         memset(vis,0,sizeof(vis));
45         fill(pos,pos+n,0);
46         for(i=0;i<n;i++)
47         {
48             scanf("%d%d",&a[i].x1,&a[i].x2);
49             a[i].num=i;
50         }
51         sort(a,a+n,cmp);
52         int last,coun=0,p;
53         for(i=0;i<n;i++)
54         {
55             if(vis[i])
56                 continue;
57             last=a[i].x2+1;
58             vis[i]=1;
59             pos[a[i].num]=++coun;
60             while(1)
61             {
62                 p=search(last);
63                 if(p==-1)
64                     break;
65                 if(vis[p])
66                     last=a[p].x1+1;
67                 else
68                 {
69                     last=a[p].x2+1;
70                     vis[p]=1;
71                     pos[a[p].num]=coun;
72                 }
73             }
74         }
75         printf("%d\n",coun);
76         for(i=0;i<n;i++)
77             printf("%d\n",pos[i]);
78     }
79 }
时间: 2024-08-10 02:02:22

Stall Reservations(POJ 3190 贪心+优先队列)的相关文章

Stall Reservations (poj 3190 贪心)

Language: Default Stall Reservations Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 3394   Accepted: 1215   Special Judge Description Oh those picky N (1 <= N <= 50,000) cows! They are so picky that each one will only be milked over so

挑战程序设计竞赛2.2习题:Stall Reservations POJ - 3190

Stall Reservations Oh those picky N (1 <= N <= 50,000) cows! They are so picky that each one will only be milked over some precise time interval A..B (1 <= A <= B <= 1,000,000), which includes both times A and B. Obviously, FJ must create a

poj 3190 贪心 + 优先队列

题意:一群牛,每头牛有固定的时间[a,b]让农夫去挤牛奶,农夫也只能在对应区间对指定奶牛进行挤奶, 求最少要多少个奶牛棚,在每个棚内的奶牛的挤奶时间不冲突. 算法:1.第一个想法就是贪心,对每头牛的挤奶时间[a,b]按a和b都从小排序,接着从左边开始找地一头牛, 然后再往右边找能够不冲突的牛再一个奶牛棚内.这个算法事件复杂度为n*n,由于最多5000头牛 所以后面还是TLE了. 2.还是自己太弱了,原来可以用优先队列进行优化,可以把当前冲突的牛放入优先队列,然后每次都能够冲优先队列 里面取出a最

Stall Reservations POJ - 3190

结构体+优先队列+贪心 #include <iostream> #include <cstdio> #include <cstring> #include <limits> //#include <stack> #include<queue> #include <algorithm> #define endl '\n' #define _for(i,a,b) for(int i=a;i<b;i++) using na

Greedy:Stall Reservations(POJ 3190)

牛挤奶 题目大意:一群牛很挑剔,他们仅在一个时间段内挤奶,而且只能在一个棚里面挤,不能与其他牛共享地方,现在给你一群牛,问你如果要全部牛都挤奶,至少需要多少牛棚? 这一题如果把时间区间去掉,那就变成装箱子问题了(装箱子要用Splay维护),但是现在规定了区间和时间,我们只用贪婪算法就可以了,每次只用找到最小就可以了(用堆维护). PS:一开始我想到用AVL去维护,的都不知道我在想什么,简直浪费时间 1 #include <iostream> 2 #include <functional&

poj 3253 贪心+优先队列【哈夫曼思想】

题目链接 题目大意: 大意:需要把一根长木棍锯成一些短木棍短木棍的长度是告诉你的每一次锯的花费为要锯的改段的长度问最小花费比如n个小木棍长度分别5 8 8也就是相当于你有一根21的木棍 现在需要把它锯成 上述的三段每次只能把一个木棍锯成两段比如21可以锯成13 和 8 但是由于选择的是21 所以花费为21第二次把13 锯成5和8 花费 为13总花费为21 + 13 = 34 分析:其实我们可以逆向思维想在有n跟木棍现在想要把他们拼成一跟每一次的花费就是这两段的和那么我们根据贪心的思想肯定是每次选

Sunscreen (poj 3614 贪心+优先队列)

Language: Default Sunscreen Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 4499   Accepted: 1565 Description To avoid unsightly burns while tanning, each of the C (1 ≤ C ≤ 2500) cows must cover her hide with sunscreen when they're at th

POJ 2431 贪心+优先队列

题意:一辆卡车距离重点L,现有油量P,卡车每前行1米耗费油量1,途中有一些加油站,问最少在几个加油站加油可使卡车到达终点或到达不了终点. 思路:运用优先队列,将能走到的加油站的油量加入优先队列中,油不够时加入优先队列中数值最大的油,如果油不够时队列里为空则到达不了. #include<cstdio> #include<queue> #include<algorithm> using namespace std; priority_queue<int> que

POJ 3190 Stall Reservations(贪心+优先队列优化)

Description Oh those picky N (1 <= N <= 50,000) cows! They are so picky that each one will only be milked over some precise time interval A..B (1 <= A <= B <= 1,000,000), which includes both times A and B. Obviously, FJ must create a reserv