杭电OJ 3190 （贪心）Stall Reservations

最新推荐文章于 2020-02-07 15:21:14 发布

mengxiang000000

最新推荐文章于 2020-02-07 15:21:14 发布

阅读量611

点赞数

分类专栏：贪心文章标签： POJ3190 poj贪心贪心 POJ

本文链接：https://blog.csdn.net/mengxiang000000/article/details/50354134

版权

贪心专栏收录该内容

186 篇文章 0 订阅

订阅专栏

Stall Reservations

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 4328		Accepted: 1547		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

Sample Output

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.

首先根据hint里边的提示看懂题意：

（当然是我的理解（没有看题干）但是意识相对了）

给你n头牛，给你栅栏，栅栏是一种长方形的东西，牛有身长，不能让两只牛重叠身体部分，求问用最少的栅栏来放牛，.第一行输出这个最少栅栏，之后的n行表示按照给出的顺序把牛分配进栅栏，输出栅栏号.

这个题目想了很久，说实话想清楚思路简单，作为新手的我们来说代码经验不足想去实现还是比较困难的一件事.

这里分两块模板进行详解：
1.如何排序.

我们知道，如果我们有一堆牛，我们要把他们放在同一个栅栏里边，如果我们想要最多的牛放在这个栅栏里边，我们要先做到的事情是理清思路，不能一味的放.这里给出实例：

2 4

9 12

3 6

5 8

9 10

11 12

如果是读者你先放进去一头牛你先放哪个？当然是先放进去 2 4然后用4和其他的开头比较，这个时候我们发现 5 9 11都比4大，这几头牛都可以放进栅栏里边，这个时候也不要一味的放，先看见顺序靠前的 9 12就放在里边，因为这个时候放进去了 9 12 我们就要拿12和后边的比较，发现这并不是最好的方案，那难道是 9 10？ 9 10 还能有个 11 12放进去，但是很可惜，这个方案还是不够好，这个时候我们就要用贪心的思维去想了，到底如何才能得到最好的解呢？

------------------小的数开始，小的数结束。上例中

5 8

9 10

11 12

9 12

这几个牛都能放进去，但是小的数开始，小的数结束的那头牛是 5 8.

所以我们试着放进去 5 8，然后是

9 10

11 12

9 12

我们依旧按照以上的规律来办--------------小的开始，小的结束.9是小的开始，10是相对12的小的结束.

这个时候我们再放进去 9 10

最后我们放进去 11 12

我们发现这样去放的确实得到的最优解.

然后我们就有了排序的观点：

小的开始，小的结束。

这里我们知道结构体排序无法完成两个变量的同时排序。所以我们这里引用一个优先队列.来完成两个变量的最小排序.

代码来源：http://blog.csdn.net/chang_mu/article/details/40982387

struct Node2 {  
    int num, u, v;  
    friend bool operator<(const Node2& a, const Node2& b) {  
        return a.v > b.v;  //小的结束.
    }   
} cow[maxn];  
int ans[maxn];  
  
bool cmp(const Node2& a, const Node2& b) {  
    return a.u < b.u;  //小的开始.
}

然后我们要解决第二个问题：

输出顺序的问题，我们这里输出顺序是按照牛入栅栏的顺序来办的，而并不是按最优解办的，这个时候我们就要有个标记来完成.

标记每个结构体的输入顺序，然后我们还需要一个数组来存输出的答案：

int ans[maxn];  //输出的数组.
        for(i = 0; i < N; ++i) {  
            scanf("%d%d", &u, &v);  
            cow[i].num = i + 1;//用这个来完成标记~  
            cow[i].u = u;  
            cow[i].v = v;  
            ans[i + 1] = 0;  //初始化.
        }

我们核心思路是要小的开始，小的结束~

我们先按照开始的数从小到大排序：

        sort(cow, cow + N, cmp);

然后队列里边按照结束的数从小到大排序：

    friend bool operator<(const Node2& a, const Node2& b) 
    {  
        return a.v > b.v;  
    }

这里排序之后的cow数组保证从小到大的开始.

这里队列保证从小到大的结束.

然后我们要做的事情就是用队头的元素的结束的数和cow数组里边的开始的数进行比较：

        priority_queue<Node2> PQ;  //优先队列的建立方式.
        PQ.push(cow[0]);  //我们首先把第一个cow放进队列。
        ans[cow[0].num] = ++sum;  //sum表示有多少个栅栏。
  
        for(i = 1; i < N; ++i) //每一头牛都要塞进去.
        {
            tmp = PQ.top();  //这里保证队头的结束的数足够小
            if(cow[i].u > tmp.v) //这里保证了当前这头牛的开始的数也足够小.//如果满足了这个条件，就相当于两头牛放在一个栅栏里边了.
            {  
                tmp.v = cow[i].v;  //这个时候我们要pop掉当前队头并且push进去新的结束的数（两头牛在里边，结束的数变大了）
                ans[cow[i].num] = ans[tmp.num];  
                PQ.pop(); PQ.push(tmp);  
            }
             else //否则就要新开一个栅栏.
            {  
                ans[cow[i].num] = ++sum;  
                PQ.push(cow[i]);  
            }  
        }

然后思路理清了这里是AC代码完整的：

#include <stdio.h>  
#include <string.h>  
#include <algorithm>  
#include <queue>  
  
#define maxn 50010  
using namespace std;  
  
struct Node2 {  
    int num, u, v;  
    friend bool operator<(const Node2& a, const Node2& b) 
    {  
        return a.v > b.v;  
    }   
} cow[maxn];  
int ans[maxn];  
  
bool cmp(const Node2& a, const Node2& b) {  
    return a.u < b.u;  
}  
  
int main() {  
    int N, i, j, sum, u, v, flag;  
    Node2 tmp;  
    while(scanf("%d", &N) == 1) {  
        sum = 0;  
        for(i = 0; i < N; ++i) {  
            scanf("%d%d", &u, &v);  
            cow[i].num = i + 1;  
            cow[i].u = u;  
            cow[i].v = v;  
            ans[i + 1] = 0;  
        }  
        sort(cow, cow + N, cmp);  
  
        priority_queue<Node2> PQ;  
        PQ.push(cow[0]);  
        ans[cow[0].num] = ++sum;  
  
        for(i = 1; i < N; ++i) 
        {
            tmp = PQ.top();  
            if(cow[i].u > tmp.v) 
            {  
                tmp.v = cow[i].v;  
                ans[cow[i].num] = ans[tmp.num];  
                PQ.pop(); PQ.push(tmp);  
            }
             else 
            {  
                ans[cow[i].num] = ++sum;  
                PQ.push(cow[i]);  
            }  
        }  
  
        printf("%d\n", sum);  
        for(i = 1; i <= N; ++i)  
            printf("%d\n", ans[i]);  
    }  
    return 0;  
}