贪心法求解活动安排(java实现)

贪心法描述：
贪心算法总是作出在当前看来最好的选择。也就是说贪心算法并不从整体最优考虑，它所作出的选择只是在某种意义上的局部最优选择。
在一些情况下，即使贪心算法不能得到整体最优解，其最终结果却是最优解的很好近似。

问题描述：
现有一组活动由你安排，但要求你在最短的时间内安排尽可能多的活动。

代码如下：
Activity类用于封装活动对象，包括活动的开始时间和结束时间，另外实现了Comparable接口，用于按照结束时间非递减排序

public class Activity implements Comparable<Activity> {
	private String startTime;//活动开始时间
	private String endTime;//活动结束时间
	public Activity(String startTime,String endTime){
		this.startTime=startTime;
		this.endTime=endTime;
	}
	/**
	 * 按照活动结束时间非递减排序
	 */
	@Override
	public int compareTo(Activity obj) {
		String targetEndTime=obj.getEndTime();
		int endHour=Integer.parseInt(endTime.split(":")[0]);
		int endMin=Integer.parseInt(endTime.split(":")[1]);
		int targetEndHour=Integer.parseInt(targetEndTime.split(":")[0]);
		int targetEndMin=Integer.parseInt(targetEndTime.split(":")[1]);
		int i=endMin>targetEndMin?1:(endMin<targetEndMin?-1:0);
		return endHour>targetEndHour?1:(endHour<targetEndHour?-1:(i));
	}
	public String getStartTime() {
		return startTime;
	}
	public void setStartTime(String startTime) {
		this.startTime = startTime;
	}
	public String getEndTime() {
		return endTime;
	}
	public void setEndTime(String endTime) {
		this.endTime = endTime;
	}
	@Override
	public String toString() {
		return startTime + "~" + endTime;
	}
}

ActivityPlan类为具体的执行类，通过其layout方法来安排活动

public class ActivityPlan {
	List<Activity> res=new ArrayList<Activity>();
	public List<Activity> layout(Iterator<Activity> activities){
		if(!activities.hasNext()){
			return res;
		}
		Activity activity=activities.next();
		int size=res.size();
		if(size==0){
			res.add(activity);
		}else{
			Activity preActivity=res.get(size-1);
			String preEndTime=preActivity.getEndTime();
			String thisStartTime=activity.getStartTime();
			if(legal(preEndTime,thisStartTime)){
				res.add(activity);
			}
		}
		return layout(activities);
	}
	/**
	 * 当前活动的开始时间是否在上一个活动的结束时间之后
	 */
	private boolean legal(String preEndTime, String thisStartTime) {
		int preHour=Integer.parseInt(preEndTime.split(":")[0]);
		int preMin=Integer.parseInt(preEndTime.split(":")[1]);
		int thisHour=Integer.parseInt(thisStartTime.split(":")[0]);
		int thisMin=Integer.parseInt(thisStartTime.split(":")[1]);
		int i=preMin>thisMin?-1:(preMin<thisMin?1:0);
		int j=preHour>thisHour?-1:(preHour<thisHour?1:(i));
		return j>=0;
	}
}

Main类用于代码测试

public class Main {
	public static void main(String[] args) {
		Set<Activity> activitys=new TreeSet<Activity>();
		activitys.add(new Activity("9:30","10:30"));
		activitys.add(new Activity("7:30","8:50"));
		activitys.add(new Activity("10:40","11:30"));
		activitys.add(new Activity("8:00","10:30"));
		activitys.add(new Activity("8:30","11:40"));
		activitys.add(new Activity("10:30","12:30"));
		ActivityPlan plan=new ActivityPlan();
		List<Activity> res=plan.layout(activitys.iterator());
		for(Activity activity:res){
			System.out.print("\t"+activity);
		}
	}
}

程序输出：7:30~8:50    9:30~10:30    10:40~11:30