[USACO]Milking Cows

Three farmers rise at 5 am each morning and head for the barn to milk three cows. The first farmer begins milking his cow at time 300 (measured in seconds after 5 am) and ends at time 1000. The second farmer begins at time 700 and ends at time 1200. The third farmer begins at time 1500 and ends at time 2100. The longest continuous time during which at least one farmer was milking a cow was 900 seconds (from 300 to 1200). The longest time no milking was done, between the beginning and the ending of all milking, was 300 seconds (1500 minus 1200).

Your job is to write a program that will examine a list of beginning and ending times for N (1 <= N <= 5000) farmers milking N cows and compute (in seconds):

• The longest time interval at least one cow was milked.
• The longest time interval (after milking starts) during which no cows were being milked.

PROGRAM NAME: milk2

INPUT FORMAT

Line 1:	The single integer
Lines 2..N+1:	Two non-negative integers less than 1000000, the starting and ending time in seconds after 0500

SAMPLE INPUT (file milk2.in)

3
300 1000
700 1200
1500 2100

OUTPUT FORMAT

A single line with two integers that represent the longest continuous time of milking and the longest idle time.

SAMPLE OUTPUT (file milk2.out)

900 300

思路：首先对区间进行排序，按照区间到左边界。然后进行遍历。注意重复边界处理。
USACO上提供到参考思路类似，首先也是根据左边界对区间进行排序，然后对区间进行合并，然后进行查找。
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Random;

public class milk2 {
	private static Random rand = new Random();
	private static int off = 10;
	public static void main(String[] args) throws IOException{
		BufferedReader br = new BufferedReader(new FileReader("milk2.in"));
		FileWriter fout = new FileWriter("milk2.out");
		//the amount of intervals
		int interval_num = Integer.parseInt(br.readLine());
		int[][] intervals = new int[interval_num][2];
		String[] tmps = null;
		//put each intervals' start and end time into a arraylist;
		for(int i = 0;i<interval_num;i++){
			tmps = br.readLine().split(" ");
			intervals[i][0]=Integer.parseInt(tmps[0]);
			intervals[i][1]=Integer.parseInt(tmps[1]);
		}
		sort(intervals,0,interval_num-1);
		int milk = intervals[0][1]-intervals[0][0];
		int milk_max = milk;
		int no_milk = 0;
		int tmp = intervals[0][1];
		System.out.println("out: "+intervals[0][0]);
		for(int i = 0;i<interval_num-1;i++){
		    System.out.println("out: "+intervals[i+1][0]);
			if(intervals[i+1][0]>tmp){
				if(intervals[i+1][0]-tmp>no_milk){
					no_milk = intervals[i+1][0]-tmp;
				}
				tmp = intervals[i+1][1];
				if(milk>milk_max){
					milk_max = milk;
				}
				milk = tmp-intervals[i+1][0];
			}else{
				if(intervals[i+1][1]>tmp){
					milk  += intervals[i+1][1]-tmp;
					tmp = intervals[i+1][1] ;
				}
			}
		}
		fout.write(milk_max+" "+no_milk+"\n");
		fout.flush();
		fout.close();
		br.close();
		System.exit(0);
		
	}
	//quicksort
	private static void sort(int[][] source,int l ,int r){
		
	    	if(l>=r) {
	    	    return;
	    	}
		int pivot = rand.nextInt(r-l)+l;
		swap(source,l,pivot);
		pivot = source[l][0];
		int left = l+1;
		int right = r;
		for(;left<right;){
			while(left<r&&source[left][0]<=pivot){
				left++;
			}
			while(source[right][0]>pivot&&right>l){
				right--;
			}
			if(left<right){
				swap(source,left,right);
			}
		}
		if(source[right][0]<pivot) {
		    swap(source,l,right);
		}
		if(right>l) {
		    	sort(source,l,right-1);
		}
		if(right<r){
			sort(source,right+1,r);
		}
	}
	
	private static void swap(int[][] source,int l ,int r){
		int[] tmp = source[l];
		source[l] = source[r];
		source[r] = tmp;
	}
}





快排写到有点烂。细节总是有问题。这次在边界上注意了。

还有一个思路：构造一个足够大的数组，可以覆盖整个时间范围，int[1000000],然后遍历所有时间区间，覆盖到区间则将数组相应到部分置为1。最后得到的数组为值为1的表已覆盖。然后问题转换为寻找最长连续1及最长连续0到自序列长度(连续0的位置不能包含0及99999)。