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
;
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
;
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
*/