ACM Cleaning Shifts(挑战程序设计竞赛)

Cleaning Shifts

Time Limit: 1000ms

Memory Limit: 65536KB

This problem will be judged on  PKU. Original ID:  2376
64-bit integer IO format:  %lld      Java class name:  Main

Prev 

Submit  Status  Statistics  Discuss

  Next

Type: 

None

NoneGraph Theory     2-SAT    Articulation/Bridge/Biconnected Component     Cycles/Topological Sorting/Strongly Connected Component     Shortest Path         Bellman Ford        Dijkstra/Floyd Warshall     Euler Trail/Circuit     Heavy-Light Decomposition    Minimum Spanning Tree     Stable Marriage Problem     Trees    Directed Minimum Spanning Tree     Flow/Matching         Graph Matching            Bipartite Matching             Hopcroft–Karp Bipartite Matching             Weighted Bipartite Matching/Hungarian Algorithm         Flow             Max Flow/Min Cut            Min Cost Max Flow DFS-like     Backtracking with Pruning/Branch and Bound     Basic Recursion    IDA* Search     Parsing/Grammar    Breadth First Search/Depth First Search     Advanced Search Techniques         Binary Search/Bisection        Ternary Search Geometry     Basic Geometry    Computational Geometry     Convex Hull     Pick's TheoremGame Theory     Green Hackenbush/Colon Principle/Fusion Principle     Nim    Sprague-Grundy Number Matrix    Gaussian Elimination     Matrix ExponentiationData Structures     Basic Data Structures    Binary Indexed Tree     Binary Search Tree     Hashing    Orthogonal Range Search     Range Minimum Query/Lowest Common Ancestor     Segment Tree/Interval Tree    Trie Tree     Sorting     Disjoint SetString     Aho Corasick    Knuth-Morris-Pratt     Suffix Array/Suffix TreeMath     Basic Math    Big Integer Arithmetic     Number Theory        Chinese Remainder Theorem         Extended Euclid         Inclusion/Exclusion        Modular Arithmetic     Combinatorics         Group Theory/Burnside's lemma        Counting     Probability/Expected Value Others    Tricky     Hardest    Unusual     Brute Force    Implementation     Constructive Algorithms    Two Pointer     Bitmask    Beginner     Discrete Logarithm/Shank's Baby-step Giant-step Algorithm     Greedy    Divide and Conquer Dynamic Programming  Tag it!

Farmer John is assigning some of his N (1 <= N <= 25,000) cows to do some cleaning chores around the barn. He always wants to have one cow working on cleaning things up and has divided the day into T shifts (1 <= T <= 1,000,000), the first being shift 1 and the last being shift T. 

Each cow is only available at some interval of times during the day for work on cleaning. Any cow that is selected for cleaning duty will work for the entirety of her interval. 

Your job is to help Farmer John assign some cows to shifts so that (i) every shift has at least one cow assigned to it, and (ii) as few cows as possible are involved in cleaning. If it is not possible to assign a cow to each shift, print -1.

Input

* Line 1: Two space-separated integers: N and T 

* Lines 2..N+1: Each line contains the start and end times of the interval during which a cow can work. A cow starts work at the start time and finishes after the end time.

Output

* Line 1: The minimum number of cows Farmer John needs to hire or -1 if it is not possible to assign a cow to each shift.

Sample Input

3 10
1 7
3 6
6 10

Sample Output

2

Hint

This problem has huge input data,use scanf() instead of cin to read data to avoid time limit exceed. 

INPUT DETAILS: 

There are 3 cows and 10 shifts. Cow #1 can work shifts 1..7, cow #2 can work shifts 3..6, and cow #3 can work shifts 6..10. 

OUTPUT DETAILS: 

By selecting cows #1 and #3, all shifts are covered. There is no way to cover all the shifts using fewer than 2 cows.

Source

USACO 2004 December Silver

贪心

#include <iostream>
#include <algorithm>
#include <cstdio>

using namespace std;

#define MAX_N 100000

int N,T;

struct Node
{
	int s,t;
} node[MAX_N];

bool cmp(const Node &a,const Node &b)
{
	if(a.s!=b.s)
		return a.s<b.s;
	return a.t<b.t;
}

int main()
{
	scanf("%d%d",&N,&T);

	for(int i=0;i<N;i++)
		scanf("%d%d",&node[i].s,&node[i].t);

	sort(node,node+N,cmp);

	int last=0;
	int cnt=1;
	int st=-1;

	while(st+1<N && node[st+1].s==1)  st++;

	if(node[st].s!=1)
	{
		printf("-1\n");
		return 0;
	}

	last=node[st].t;
	int nowt=st;
	int maxlast=last;
	int lasti=st;

	while(last<T && nowt<N)
	{
		int ti;
		for(ti=nowt+1;ti<N;ti++)
		{
			if(last+1<node[ti].s)
				break;
			else
			{
				if(maxlast<node[ti].t)
				{
					maxlast=node[ti].t;
					lasti=ti;
				}
			}
		}
		if(ti==nowt+1)
			break;
		else
		{
			last=maxlast;
			nowt=lasti;
			cnt++;
		}
	}

	if(last<T)
		printf("-1\n");
	else
		printf("%d\n",cnt);

	return 0;
}