Cleaning Shifts Java实现

Cleaning Shifts

OJ链接： Cleaning Shifts

题目描述：

Description
	农夫约翰正在分配他的两万五千头牛在谷仓周围做一些清洁工作。他总是希望有一头牛在清理东西，并将一天分为T班（1<=T<=1000000），第一班是1班，最后一班是T班。
每头牛只能在白天的某些时间间隔内进行清洁工作。任何被选为清洁工作的母牛都将在整个间隔时间内工作。
你的工作是帮助农夫约翰分配一些奶牛轮班，以便（i）每个轮班至少分配一头奶牛，以及（ii）尽可能少的奶牛参与清洁。如果无法为每班分配一头奶牛，请打印-1。

Input
*第1行：两个空格分隔的整数：N和T
*第2行。。N+1：每行包含奶牛工作时间间隔的开始和结束时间。奶牛在开始时间开始工作，在结束时间后结束工作。
Ouput
*第1行：农夫约翰需要雇佣的奶牛的最小数量，如果不能为每个班次分配一头奶牛，则为-1。

样例输入输出：

Sample Input

3 10
1 7
3 6
6 10

Sample Output

2

提示：

这个问题有大量的输入数据，使用scanf（）代替cin读取数据以避免超过时间限制。

输入详细信息：
有3头牛和10个轮班。奶牛可以轮班工作。。牛2可以轮班工作3。。6.牛3可以轮班工作6。。10
输出详细信息：
2

题目分析：

• 使用贪心算法解决
• 第一头牛必须是1开头，然后尽量工作时间久
• 接下来没一头牛都必须满足开始的工作时间在前面一头牛的 Start到End之间，且工作时间尽可能的晚。
• 如果到最后无法覆盖全部区域，则输出-1。

题目代码：

package javaBase;


import java.io.*;
import java.util.*;
import java.math.*;

public class Main{
    static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    static BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
    
    static class node implements Comparable<node>{ 
        int l, r;                              
        node(int l, int r){                   
            this.l = l;
            this.r = r;
        }
        //定义排序算法，以起始工作时间排序
        public int compareTo(node b) {
            return this.l - b.l;
        } 
    }
    
    static node[] arr = new node[25005];
    
    static int Int(String s){
        return Integer.parseInt(s);
    }
    
    public static void main(String[] args) throws Exception{
    	  //T头牛、N个班
        int T, n;
        String[] s = in.readLine().split(" ");
        n = Integer.parseInt(s[0]);
        T = Integer.parseInt(s[1]);
        
        for(int i = 0; i < n; i++){
        	String[] s1 = in.readLine().split(" ");// 读入
        	arr[i] = new node(Int(s1[0]), Int(s1[1]));
        }
        
        Arrays.sort(arr, 0, n - 1); // 排序
        
        int flag = 0, res = 0, start = 1; // // 刚开始1时刻是未被覆盖的区间的起始时刻
     
        for(int i = 0; i < n; i++){
            int j = i;
			int r = -1000;
            
            if(arr[0].l > 1){
                break;
            }
            //不蹲循环遍历，从中找出起始时间满足条件，且结束时间最晚的牛
            while(j < n &&(start != 1 &&arr[j].l <= start+1|| start == 1 && arr[j].l == 1)){
                r = Math.max(r, arr[j].r);
                j ++;
            }
            //需要的牛+1
            res ++;
            if(r < start){ // 如果r < start说明没有符合条件的区间。直接break输出-1
                break;
            }
            
            if(r >= T   ){ // 如果 r >= T 说明区间已经被完全覆盖，break输出答案
                flag = 1;
                break;
            }
            
            start = r; // 更新起始时刻
            i = j - 1; // 0 ~ j-1个区间已经遍历过了，直接跳过。
        }
        if(flag != 1) res = -1;
        out.write(Integer.toString(res));
        out.flush();
    }
}