Expm 8_1 区间划分问题

 

【问题描述】

给定一组报告，其中的每个报告设置了一个开始时间s_i和结束时间f_i。设计与实现一个算法，对这组报告分配最少数量的教室，使得这些报告能无冲突的举行。

package org.xiu68.exp.exp8;

import java.util.ArrayList;
import java.util.Comparator;

public class Exp8_1 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ArrayList<Report> reports=new ArrayList<>();
            reports.add(new Report(7,10));
            reports.add(new Report(8,11));
            reports.add(new Report(9,13));            
            reports.add(new Report(12,14));
            reports.add(new Report(13,15));
            intervalPartition(reports);
    }
    
    public static void intervalPartition(ArrayList<Report> reports){
        reports.sort(new comp());    //按开始时间对报告进行排序
        
        //不使用优先队列
        //ArrayList<Integer> classrooms=new ArrayList<>();
        //classrooms.get(i)表示第i间教室的报告的结束时间
        //classrooms.add(reports.get(0).endTime);
        
        //使用优先队列
        PriorityQueue<ClassRoom> classrooms=new PriorityQueue<>();
        //首先为第1份报告分配教室
        classrooms.add(new ClassRoom(reports.get(0).endTime));
    
        for(int i=1;i<reports.size();i++){
            //不使用优先队列
            /*boolean flag=false;        //是否找到教室
            for(int j=0;j<classrooms.size();j++){
                if(reports.get(i).startTime>=classrooms.get(j)){    //找到教室
                    classrooms.set(j, reports.get(i).endTime);
                    flag=true;
                    break;
                }
            }
            if(flag==false){        //找不到教室，另分配一间教室
                classrooms.add(reports.get(i).endTime);
            }*/
            
            //使用优先队列
            if(reports.get(i).startTime>=classrooms.getMin().endTime){    //找到教室
                //教室来了新报告后需要调整使用教室的结束时间
                classrooms.setFirstElement(new ClassRoom(reports.get(i).endTime));
            }else{   
                classrooms.add(new ClassRoom(reports.get(i).endTime));   //找不到教室,新开辟一间教室
            }
            
        }
        System.out.println("最少需要  "+classrooms.size()+" 间教室");
    }
    
}

class Report{
    public int startTime;    //开始时间
    public int endTime;        //结束时间
    
    public Report(int startTime, int endTime) {
        super();
        this.startTime = startTime;
        this.endTime = endTime;
    }
}

class ClassRoom implements Comparable<ClassRoom>{
    public int endTime;
    public ClassRoom(int endTime){
        this.endTime=endTime;
    }
    @Override
    public int compareTo(ClassRoom o) {
        // TODO Auto-generated method stub
        if(endTime>o.endTime)
            return 1;
        else
            return -1;
    }
}
class comp implements Comparator<Report>{
    @Override
    //按开始时间排序报告的比较方法
    public int compare(Report r1, Report r2) {
        // TODO Auto-generated method stub
        if(r1.startTime>r2.startTime)
            return 1;
        else
            return -1;
    }
}

package org.xiu68.exp.exp8;

import java.util.Comparator;
import java.util.NoSuchElementException;


public class PriorityQueue<E extends Comparable<E>> {
    private E[] heap;
    private int size;
    private Comparator<E> comp;
    
    @SuppressWarnings("unchecked")
    public PriorityQueue(){
        heap=(E[])new Comparable[5];
    }
    public PriorityQueue(Comparator<E> comp){
        this();
        this.comp=comp;
    }
    
    @SuppressWarnings("unused")
    private int compare(E e1,E e2){
        if(comp==null)
            return e1.compareTo(e2);
        else
            return comp.compare(e1, e2);
    }
    
    @SuppressWarnings("unchecked")
    public void add(E element){
        //如果添加元素后数组已满，则先扩容再加入
        if(++size==heap.length){
            E[] e=(E[])new Comparable[heap.length*2];
            System.arraycopy(heap, 0, e, 0, size);
            heap=e;
        }
        heap[size-1]=element;
        adjust();
    }
    
    //设置堆顶元素，需要从堆顶开始调整堆
    public void setFirstElement(E element){
        if(size<=0){
            throw new NoSuchElementException();
        }
        heap[0]=element;
        adjustFromIndex(0);
    }
    public void adjustFromIndex(int i){
        //由于从序号为0开始存储，需要加这段
        if(i==0 && size>1){
            int j;
            if(size>2){        //大于等于3个元素
                 j=(compare(heap[i+1],heap[i+2])>0?i+1:i+2);  //j为左右孩子的最小者的下标
            }else{          //只有两个元素
                 j=i+1;
            }
            if(compare(heap[i],heap[j])>0){    //父结点大于子结点,交换值
                E temp=heap[i];
                heap[i]=heap[j];
                heap[j]=temp;
            }
            adjustFromIndex(j);
        }
        
        int parent=i;
        int child=2*i;
        while(child<=size-1){
            //child<size-1表示parent左右孩子都存在
            //child存放左右孩子最大者数组下标
            if(child<size-1 && compare(heap[child],heap[child+1])>0){ 
                child+=1;
            }
            if(compare(heap[parent],heap[child])<=0){  //父结点大于子结点，停止调整
                break;
            }else{
                E temp=heap[parent];
                heap[parent]=heap[child];
                heap[child]=temp;
                parent=child;
                child=2*parent;
            }
        }
    }
    //从新加入元素开始调整堆
    public void adjust(){
        int newElement=size-1;
        int parentElement;
        while(newElement>0){                //还没有调整到根结点
            parentElement=newElement/2;        //根结点为newElement/2向下取整
            
            //如果父结点小于等于子结点则不需要调整
            if(compare(heap[parentElement],heap[newElement])<=0){
                break;
            }
            //交换父结点与子结点的值
            E temp=heap[parentElement];
            heap[parentElement]=heap[newElement];
            heap[newElement]=temp;
            newElement=parentElement;
        }
    }
    //获取最小元素
    public E getMin(){
        if(size==0){
            throw new NoSuchElementException();
        }
        return heap[0];
    }
    //返回队列大小
    public int size(){
        return size;
    }
}