【华为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;
            }
        }
    }
}