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

  None

 Graph 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 Theorem

 Game Theory

      Green Hackenbush/Colon Principle/Fusion Principle

      Nim

     Sprague-Grundy Number

  Matrix

     Gaussian Elimination

      Matrix Exponentiation

 Data 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 Set

 String

      Aho Corasick

     Knuth-Morris-Pratt

      Suffix Array/Suffix Tree

 Math

      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;
}