【华为OD机试真题】单核CPU任务调度

单核CPU任务调度
考察的知识的点就一个优先队列（队列排序）
题目描述：
现在有一个CPU和一些任务需要处理，已提前获知每个任务的任务D、优先级、所需执行时间和到达时间。
CPU同时只能运行一个任务，请编写一个任务调度程序，采用“可抢占优先权调度”调度算法进行任务调度，规则如
下：
如果一个任务到来时，CPU是空闲的，则CPU可以运行该任务直到任务执行完毕。但是如果运行中有一个更高优先级
的任务到来，则CPU必须暂停当前任务去运行这个优先级更高的任务；
如果一个任务到来时，CPU正在运行一个比它优先级更高的任务时，新到达的任务必须等待：
当CPU空闲时，如果还有任务在等待，CPU会从这些任务中选择一个优先级最高的任务执行，相同优先级的任务选择
到达时间最早的任务。

输入描述：
输入有若干行，每一行有四个数字（均小于108），分别为任务引D,任务优先级，执行时间和到达时间。每个任务的任务引D不同，
优先级数字越大优先级越高，井且相同优先级的任务不会同时到达。
输入的任务已按照到达时间从小到达排列，并且保证在任何时间，处于等待的任务不超过10000个。
输出描述：
按照任务执行结束的顺序，输出每个任务的任务引D和对应的结束时间。
示例1
输入：
1 3 5 1
2 1 5 10
3 2 7 12
4 3 2 20
5 4 9 21
6 4 2 22
输出：
1 6
3 19
5 30
6 32
4 33
2 35
以下示例是自己创建的
示例2
输入：
1 3 5 1
2 2 5 2
输出：
1 6
2 11
示例3
输入：
1 3 5 1
2 2 5 2
3 4 6 3

输出：
3 9
1 12
2 17
示例4
输入：
1 3 5 1
2 3 5 2
输出：
1 6
2 11

public class 单核cpu任务调度 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        List<Task> tasks = new ArrayList<>();
        while (true) {
            String value = in.nextLine();
            if ("".equals(value)) {
                break;
            }
            String[] valueArr = value.split(" ");
            String id = valueArr[0];
            Long pro = Long.parseLong(valueArr[1]);
            Long excTime = Long.parseLong(valueArr[2]);
            Long adrTime = Long.parseLong(valueArr[3]);
            tasks.add(new Task(id, pro, excTime, adrTime));
        }
        PriorityQueue<Task> queue = new PriorityQueue<>();
        long time = 0;
        for (Task task : tasks) {
            long h = task.startTime - time;
            while (!queue.isEmpty() && h > 0) {
                if (queue.peek().excTime<=h) {
                    Task tmp = queue.poll();
                    h= h-tmp.excTime;
                    time = time+tmp.excTime;
                    System.out.println(tmp.id+" "+time);
                } else {
                    Task tmp = queue.peek();
                    tmp.excTime -=h;
                    time +=h;
                    break;
                }
            }
            if (time < task.startTime) {
                time = task.startTime;
            }
            queue.add(task);
        }
        while (!queue.isEmpty()) {
           Task t =queue.poll();
           time += t.excTime;
            System.out.println(t.id+" "+time);
        }
    }
    static class Task implements Comparable<Task> {
        String id;
        Long pro;
        Long excTime;
        Long startTime;
        public Task(String id, Long pro, Long excTime, Long startTime) {
            this.id = id;
            this.pro = pro;
            this.excTime = excTime;
            this.startTime = startTime;

        }
        @Override
        public int compareTo(Task o) {
            // 返回-1 是上面，1是下面，相等的时候谁来的早放上面
            if (this.pro>o.pro) {
                return -1;
            } else {
                return 1;
            }
        }
    }
}