nyoj_14_会场安排问题(贪心)

• 题目14
• 题目信息
• 运行结果
• 本题排行
• 讨论区

会场安排问题

时间限制： 3000 ms  |  内存限制： 65535 KB

难度： 4

描述

学校的小礼堂每天都会有许多活动，有时间这些活动的计划时间会发生冲突，需要选择出一些活动进行举办。小刘的工作就是安排学校小礼堂的活动，每个时间最多安排一个活动。现在小刘有一些活动计划的时间表，他想尽可能的安排更多的活动，请问他该如何安排。

输入

第一行是一个整型数m(m<100)表示共有m组测试数据。
每组测试数据的第一行是一个整数n(1<n<10000)表示该测试数据共有n个活动。
随后的n行，每行有两个正整数Bi,Ei(0<=Bi,Ei<10000),分别表示第i个活动的起始与结束时间（Bi<=Ei)

输出

对于每一组输入，输出最多能够安排的活动数量。
每组的输出占一行

样例输入

2
2
1 10
10 11
3
1 10
10 11
11 20

样例输出

1
2

提示

注意：如果上一个活动在t时间结束，下一个活动最早应该在t+1时间开始

来源

经典题目

上传者

张云聪

//在有一大堆活动时，我们最先应该选择结束时间最早的那个，以利于之后能安排更多的活动，然后，再在剩下的可选的会场中选择最可能结束时间最早的那个，依次类推，直

//到无法安排任何活动为止。
// 也就是说，每次选择时，都应该贪婪的选择结束时间最短的那个活动。注意：如果上一个活动在t时间结束，下一个活动最早应该在t+1时间开始

import java.util.Comparator;
import java.util.Iterator;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeSet;

public class nyoj_14_会场安排问题 {
//虽然方法写时过于长了，但是学会了，写个类似结构体的方法来解决问题
	public static void main(String[] args) {
      //chenguichao 会场安排问题 Accepted  792  2743 java 09-02 22:26:57   
        Scanner sc=new Scanner(System.in);
           int T =sc.nextInt();
           while(T-->0){
        	 int n=sc.nextInt();
        	Set<F> ts=new TreeSet<F>(new SORT());
        	     
        	 for(int i=0; i<n; i++){
        		 
        		 int a=sc.nextInt();
        		 int b=sc.nextInt(); 
        		 F f =new F(a,b);/*不可写成：f[i].a=sc.nextInt(); 
				   ts.add(f);                  f[i].b=sc.nextInt(); ts.add(f[i]);*/
        		          		      	 
        	 }       
        	 F  ff[] = new F[n];
           	 Iterator<F> it=ts.iterator();
           	 int e=-1;
        	 while(it.hasNext()){ //         		
        		 ff[++e]=it.next();      		 
        	 }
           	 int count=1;
           	 int nn=ff[0].b;
           	 int mm;
           	 for(int i=0;i<n;i++){
           		mm=ff[i].a;
           		 if(nn<mm){
           			 nn=ff[i].b;
           			 count++;
           		 }
           	 }
           	 System.out.println(count);
        	ts.clear();        	 
           }   
	}
}
class SORT implements Comparator<F>{

		@Override
		public int compare(F o1, F o2) {
			if(o1.b==o2.b)//添加重复的，或说将b来排序时有相同的时处理方法
				return -1;
			return (o1.b-o2.b);
		}			  
}
class  F{//相当于C语言的结构体！
	int a,b;//相当于指针
	F(int a,int b){
		this.a=a;
		this.b=b;
	}
	F(){}
}

直接按结束时间用冒泡排序也可以！！

 
import java.util.Scanner;

public class Main{
	public static void main(String[] args){
		Scanner x=new Scanner(System.in);
		int n=x.nextInt();
		while(n--!=0){
			int m=x.nextInt();
			int a[]=new int[10010];
			int b[]=new int[10010];
			for(int i=0;i<m;i++){
				a[i]=x.nextInt();//开始时间
				b[i]=x.nextInt();//结束时间
			}
			for(int i=0;i<m-1;i++)//按开始时间排序
				for(int j=i+1;j<m;j++)
					if(a[i]>a[j]){
						int t=a[i];
						a[i]=a[j];
						a[j]=t;
						t=b[i];
						b[i]=b[j];
						b[j]=t;
					}
			int sum=1;
			int t=b[0];
			for(int i=1;i<m;i++){
				if(b[i]<t)
					t=b[i];
				if(a[i]>t){
					sum++;
					t=b[i];
				}
			}
			System.out.println(sum);	
		}
	}
}        

测试时代码：

import java.util.Comparator;
import java.util.Iterator;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeSet;

public class Comparable_tree_比较_排序 {

	public static void main(String[] args) {
        
        Scanner sc=new Scanner(System.in);
           int T =sc.nextInt();
           while(T-->0){
        	 int n=sc.nextInt();
        	Set<F> ts=new TreeSet<F>(new SORT());//Tree
        	// Set<F> ts=new TreeSet<F>();
        	 for(int i=0; i<n; i++){
        		 
        		 int a=sc.nextInt();
        		 int b=sc.nextInt(); 
        		 F f =new F(a,b);
        		 ts.add(f);        	 
        	 }      
        	 F  f[] = new F[n];
           	 Iterator<F> it=ts.iterator();
           	 int e=-1;
        	 while(it.hasNext()){          		
        		 f[++e]=it.next();
        		 
        	 } for(F temp:f){
        		
        		 System.out.println(temp.toSring());
        	 }
        	 
           }
	}
}
class SORT implements Comparator<F>{
		@Override
		public int compare(F o1, F o2) {
			if(o1.b==o2.b)
				return -1;
			return (o1.b-o2.b);
		}	 
}
 class  F{
	 int a,b;	
	F(int a,int b){
		this.a=a;
		this.b=b;		
	}
	F(){}
	public String toSring(){		
		return a+" "+b;
	}
}
/*
 * 按  b的升序  排序！！！
 case: 1
输入：
3
10
3 8 1 4 3 5 0 6 6 10 5 7 5 9 8 12 8 11 2 13
输出：
1 4
3 5
0 6
5 7
3 8
5 9
6 10
8 11
8 12
2 13
case: 2
输入：
3
10
3 8 1 4 3 5 0 6 6 10 5 7 5 9 8 12 8 11 3 8
输出：
1 4
3 5
0 6
5 7
3 8
3 8
5 9
6 10
8 11
8 12
 */