Java算法_优先队列和PriorityQueue——HDU 1873：看病要排队

优先队列和PriorityQueue

java.util.PriorityQueue

优先级队列priority queue中的元素可按照任意的顺序插入，却总是按照排序的顺序进行检索。优先级队列使用堆（heap）数据结构实现。

//构造函数
public PriorityQueue()
public PriorityQueue(int initialCapacity)
public PriorityQueue(Comparator<? super E> comparator)
public PriorityQueue(int initialCapacity, Comparator<? super E> comparator)
public PriorityQueue(Collection<? extends E> c)
public PriorityQueue(PriorityQueue<? extends E> c)
public PriorityQueue(SortedSet<? extends E> c)

常用API

方法名	功能描述
add(E e)	添加元素
clear()	清空
contains(Object o)	检查是否包含当前参数元素
offer(E e)	添加元素
peek()	读取元素，（不删除）
poll()	取出元素，（删除）
remove(Object o)	删除指定元素
size()	返回长度

HDU 1873：看病要排队

http://acm.hdu.edu.cn/showproblem.php?pid=1873

Problem Description
 看病要排队这个是地球人都知道的常识。
 不过经过细心的0068的观察，他发现了医院里排队还是有讲究的。0068所去的医院有三个医生（汗，这么少）同时看病。而看病的人病情有轻重，所以不能根据简单的先来先服务的原则。所以医院对每种病情规定了10种不同的优先级。级别为10的优先权最高，级别为1的优先权最低。医生在看病时，则会在他的队伍里面选择一个优先权最高的人进行诊治。如果遇到两个优先权一样的病人的话，则选择最早来排队的病人。
现在就请你帮助医院模拟这个看病过程。

Input
输入数据包含多组测试，请处理到文件结束。
每组数据第一行有一个正整数N(0<N<2000)表示发生事件的数目。
接下来有N行分别表示发生的事件。
一共有两种事件：
1:“IN A B”,表示有一个拥有优先级B的病人要求医生A诊治。(0<A<=3,0<B<=10)
2:“OUT A”,表示医生A进行了一次诊治，诊治完毕后，病人出院。(0<A<=3)

Output

对于每个"OUT A"事件，请在一行里面输出被诊治人的编号ID。如果该事件时无病人需要诊治，则输出"EMPTY"。
诊治人的编号ID的定义为：在一组测试中，"IN A B"事件发生第K次时，进来的病人ID即为K。从1开始编号。

Sample Input

7
IN 1 1
IN 1 2
OUT 1
OUT 2
IN 2 1
OUT 2
OUT 1
2
IN 1 1
OUT 1

Sample Output

2
EMPTY
3
1
1

 优先队列，结构体排序，分别建立 3 个医生的队列，先按优先级排序，优先级相等的情况下按病人的顺序排序

package com.hhhyixin.book.cp03.hdu_1873;

import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        new Main().solve();
    }

    static Comparator<Patient> cPatient = new Comparator<Patient>() {
        @Override
        public int compare(Patient o1, Patient o2) {//定义优先级规则
            if (o1.level != o2.level) {
                return o2.level - o1.level;
            }
            return o1.id - o2.id;
        }
    };

    public void solve() {
        PriorityQueue[] queue = new PriorityQueue[3];//定义长度为3的优先级队列
        int T, doctorId, patientLevel;
        Scanner in = new Scanner(System.in);
        while (in.hasNext()) {
            T = in.nextInt();//要输入的行数
            queue[0] = new PriorityQueue<>(cPatient);
            queue[1] = new PriorityQueue<>(cPatient);
            queue[2] = new PriorityQueue<>(cPatient);
            int id = 1;
            while ((T--) != 0) {
                String op = in.next();//输入是"IN"还是"OUT"
                if ("IN".equals(op)) {//如果输入的是"IN",进循环
                    doctorId = in.nextInt();//输入医生的id
                    patientLevel = in.nextInt();//输入病人的优先级
                    queue[doctorId - 1].add(new Patient(id++, patientLevel));
                    //doctorId-1是因为doctorId的只能是1、2、3，而queue[]中是0、1、2，减1是为了让二者相照应，后面的id++也是这个道理

                } else {//如果输入的是"OUT"
                    doctorId = in.nextInt();//输入医生id
                    if (!queue[doctorId - 1].isEmpty()) {//如果把医生id对应到queue最队列中发现有让该医生治病的病人，就根据优先级进行治疗
                        Patient patient = (Patient) queue[doctorId - 1].poll();//取出元素之后删除(治疗过病人之后删除病人id)
                        System.out.println(patient.id);//输出治疗过后的病人id
                    } else {
                        System.out.println("EMPTY");
                    }
                }
            }
        }
    }

}

class Patient {//定义一个病人实体类
    int id;//编号
    int level;//等级

    public Patient(int id, int level) {
        this.id = id;
        this.level = level;
    }
}

java.util.Comparator

 java.util.Comparator接口为一个比较器接口，它提供了一个自定义比较规则的方法，可以根据需要对不支持比较的对象按自己的逻辑进行排序，一般与Collections.sort（）方法一起使用。

Arrays.sort(T[],Comparator<? super T> c);  //数组工具类sort
Collections.sort(List<T> list,Comparator<? super T> c); //集合工具类sort