贪心算法之区间调度问题

问题描述

有n项工作，每项工作分别在si时间开始，在ti时间结束
对于每项工作，可以参与也可以不参与，如果参与必须全程参与，不能中途退出
此外，参与工作的时间不能重叠
如何才能参与尽可能多的工作，能参与多少项工作
输入：
第一行：整数n,代表工作数
第二行：n个整数，代表每项工作的开始时间
第三行：n个整数，代表每项工作的结束时间

样例输入：

5
1 2 4 6 8
3 5 7 9 10

样例输出：

3

思路

• 本题采用贪心策略，经测试，每次选最早结束的工作可以参加最多次数的工作
• 所以，将工作按照结束时间排序，结束时间早的放前面
• 为了方便排序，创建一个Job类实现Compareable，有属性开始时间和结束时间，一个有参构造方法，并且重写compareTo（）方法
• 每次选择开始时间大于上一个工作结束时间的工作，并记录当前选择工作的结束时间

代码

import java.util.Scanner;
import java.util.Arrays;
public class 区间调度问题 {
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		int n = input.nextInt();
		int[] begin = new int[n];
		int[] end = new int[n];
		for (int i = 0; i < begin.length; i++) {
			begin[i] = input.nextInt();
		}
		for (int i = 0; i < end.length; i++) {
			end[i] = input.nextInt();
		}
		input.close();
		Job[] job = new Job[n];
		for (int i = 0; i < job.length; i++) {
			job[i] = new Job(begin[i], end[i]);
		}
		Arrays.sort(job);
		/*
		 * for (Job job2 : job) { System.out.println(job2.toString()); }
		 */
		System.out.println(solution(job));
	}
	private static int solution(Job[] job) {
		int count = 0;
		int i = 0;
		int temp = -1;
		while(i < job.length) {
			if(job[i].begin > temp) {
				temp = job[i].end;
				count++;
				i++;
			}
			else {
				i++;
			}
			
		}
		return count;
	}
	private static class Job implements Comparable<Job>{
		int begin;
		int end;
		public Job(int begin, int end) {
			this.begin = begin;
			this.end = end;
		}
		@Override
		public int compareTo(Job job) {
			if(this.end > job.end)
			return 1;
			else if(this.end == job.end)
				return 0;
			else
				return -1;
		}
		@Override
			public String toString() {
				// TODO Auto-generated method stub
				return this.begin + " " + this.end;
			}
		
	}
}