【一起刷题】优先队列PriorityQueue

优先队列PriorityQueue

1 模板

Queue<Integer> q = new PriorityQueue<Integer>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1-o2;    //小根堆
                //return o1.compareTo(o2);	//小根堆 
                //return o2-o1;	//大根堆
                //return o2.compareTo(o1);	//大根堆
            }
        });

注意这里的顺序一定要记清楚。
记忆方法：
小根堆上小下大 o1-o2
大根堆上大下小 o2-o1

2 实战

（1）魔塔游戏

优先队列+贪心

魔塔游戏

小扣当前位于魔塔游戏第一层，共有 N 个房间，编号为 0 ~ N-1。每个房间的补血道具/怪物对于血量影响记于数组 nums，其中正数表示道具补血数值，即血量增加对应数值；负数表示怪物造成伤害值，即血量减少对应数值；0 表示房间对血量无影响。

小扣初始血量为 1，且无上限。假定小扣原计划按房间编号升序访问所有房间补血/打怪，为保证血量始终为正值，小扣需对房间访问顺序进行调整，每次仅能将一个怪物房间（负数的房间）调整至访问顺序末尾。请返回小扣最少需要调整几次，才能顺利访问所有房间。若调整顺序也无法访问完全部房间，请返回 -1。

示例 1：

输入：nums = [100,100,100,-250,-60,-140,-50,-50,100,150]

输出：1

解释：初始血量为 1。至少需要将 nums[3] 调整至访问顺序末尾以满足要求。

示例 2：

输入：nums = [-200,-300,400,0]

输出：-1

解释：调整访问顺序也无法完成全部房间的访问。

提示：

1 <= nums.length <= 10^5
-10^5 <= nums[i] <= 10^5

class Solution {
    public int magicTower(int[] nums) {
        Queue<Integer> q = new PriorityQueue<Integer>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1.compareTo(o2);    //小根堆 存负数 所以越小的数字 绝对值越大  
            }
        });
        
        long s = 1;
        for(int num : nums) {
            s += num;
        }
        if(s <= 0) return -1;
        
        int res = 0;
        long blood = 1L;
        for(int i = 0; i < nums.length; i++) {
            int now = nums[i];
            if(now >= 0) {
                blood += now;
                continue;
            }
            
            blood += now;   //每次都将now加入  如果挂起则加回去
            //每次都将负的数字加到树里面，我们率先将较大的放到后面 相当于是补血了
            q.add(now);
            while(blood <= 0) {
                res++;
                blood -= q.poll();  //将扣掉的血补回来
            }
            
        }
        
        return res;
    }
}

每次将遇到的负数 都可以挪出来 存起来 每次先将经过的最小的负数（绝对值最大的负数）血补回来 这样先把扣血最多的局部先去掉。

（2）单线程 CPU

给你一个二维数组 tasks ，用于表示 n​​​​​​ 项从 0 到 n - 1 编号的任务。其中 tasks[i] = [enqueueTimei, processingTimei] 意味着第 i​​​​​​​​​​ 项任务将会于 enqueueTimei 时进入任务队列，需要 processingTimei 的时长完成执行。

现有一个单线程 CPU ，同一时间只能执行 最多一项 任务，该 CPU 将会按照下述方式运行：

如果 CPU 空闲，且任务队列中没有需要执行的任务，则 CPU 保持空闲状态。
如果 CPU 空闲，但任务队列中有需要执行的任务，则 CPU 将会选择 执行时间最短 的任务开始执行。如果多个任务具有同样的最短执行时间，则选择下标最小的任务开始执行。
一旦某项任务开始执行，CPU 在 执行完整个任务 前都不会停止。
CPU 可以在完成一项任务后，立即开始执行一项新任务。
返回 CPU 处理任务的顺序。

输入：tasks = [[1,2],[2,4],[3,2],[4,1]]
输出：[0,2,3,1]
解释：事件按下述流程运行： 
- time = 1 ，任务 0 进入任务队列，可执行任务项 = {0}
- 同样在 time = 1 ，空闲状态的 CPU 开始执行任务 0 ，可执行任务项 = {}
- time = 2 ，任务 1 进入任务队列，可执行任务项 = {1}
- time = 3 ，任务 2 进入任务队列，可执行任务项 = {1, 2}
- 同样在 time = 3 ，CPU 完成任务 0 并开始执行队列中用时最短的任务 2 ，可执行任务项 = {1}
- time = 4 ，任务 3 进入任务队列，可执行任务项 = {1, 3}
- time = 5 ，CPU 完成任务 2 并开始执行队列中用时最短的任务 3 ，可执行任务项 = {1}
- time = 6 ，CPU 完成任务 3 并开始执行任务 1 ，可执行任务项 = {}
- time = 10 ，CPU 完成任务 1 并进入空闲状态

输入：tasks = [[7,10],[7,12],[7,5],[7,4],[7,2]]
输出：[4,3,2,0,1]
解释：事件按下述流程运行： 
- time = 7 ，所有任务同时进入任务队列，可执行任务项  = {0,1,2,3,4}
- 同样在 time = 7 ，空闲状态的 CPU 开始执行任务 4 ，可执行任务项 = {0,1,2,3}
- time = 9 ，CPU 完成任务 4 并开始执行任务 3 ，可执行任务项 = {0,1,2}
- time = 13 ，CPU 完成任务 3 并开始执行任务 2 ，可执行任务项 = {0,1}
- time = 18 ，CPU 完成任务 2 并开始执行任务 0 ，可执行任务项 = {1}
- time = 28 ，CPU 完成任务 0 并开始执行任务 1 ，可执行任务项 = {}
- time = 40 ，CPU 完成任务 1 并进入空闲状态

class Solution {
    public int[] getOrder(int[][] tasks) {
        PriorityQueue<int[]> pq = new PriorityQueue<>(new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                if(o1[1] == o2[1]) {
                    return o1[2] - o2[2];
                } else {
                    return o1[1] - o2[1];
                }
            }
        });
        int[][] copyTasks = new int[tasks.length][3];
        for(int i = 0; i < tasks.length; i++) {
            copyTasks[i][0] = tasks[i][0];
            copyTasks[i][1] = tasks[i][1];
            copyTasks[i][2] = i;
        }
        Arrays.sort(copyTasks, new Comparator<int[]>() {
           @Override
            public int compare(int[] o1, int[] o2) {
                if(o1[0] == o2[0]) {
                    if(o1[1] == o2[1]) {
                        return o1[2] - o2[2];
                    } else {
                        return o1[1] - o2[1];
                    }
                } else {
                    return o1[0] - o2[0];
                }
            }
        });
        int curTime = 0;
        int[] res = new int[copyTasks.length];
        int index = 0;
        for(int i = 0; i < copyTasks.length; i++) {
            if(curTime >= copyTasks[i][0]) {
                pq.add(copyTasks[i]);
            } else {
                while(!pq.isEmpty() && curTime < copyTasks[i][0]) {
                    int[] next = pq.poll();
                    res[index++] = next[2];
                    curTime = Math.max(curTime, next[0]) + next[1];
                }
                pq.add(copyTasks[i]);
                curTime = Math.max(curTime, copyTasks[i][0]);
            }
        }
        while(!pq.isEmpty()) {
            int[] next = pq.poll();
            res[index++] = next[2];
            curTime = Math.max(curTime, next[0]) + next[1];
        }
        return res;
    }
}