挑战程序竞赛系列（9）：2.4优先队列

详细代码可以fork下Github上leetcode项目，不定期更新。

练习题如下：

• POJ 3614: Sunscreen
• POJ 2010: Moo University - Financial Aid

POJ 3614: Sunscreen

奶牛美容：有C头奶牛日光浴，每头奶牛分别需要minSPF_i和maxSPF_i单位强度之间的阳光。现有L种防晒霜，分别能使阳光强度稳定为SPF_i，其瓶数为cover_i。求最多满足多少头奶牛

翻译参考：博文【POJ 3614 Sunscreen 题解 《挑战程序设计竞赛》】

思路：

• 防晒霜要从小到大排序，优先处理小的防晒霜。
• 奶牛按照minSPF从小到大排序，这样在所有符合某防晒霜的cow中，挑选maxSPF最小的。很直观，maxSPF越大，选择的余地越多。

代码为什么使用优先队列？

比如：奶牛的minSPF和maxSPF数据如下：
a牛： 1  8
b牛： 2  7
c牛： 3  6
防晒霜如下：
4  2
那么我们应该选择第c头牛，如果还有防晒霜则再给b牛。因为a牛选择的余地最大，所以暂且放到最后再考虑。

代码如下：

public class SolutionDay26_P3614 {

    public static void main(String[] args) {
        Scanner in= new Scanner(System.in);
        int C = in.nextInt();
        int L = in.nextInt();
        int[][] cows = new int[C][2];
        int[][] lotions = new int[L][2];
        for (int i = 0; i < C; i++){
            cows[i][0] = in.nextInt();
            cows[i][1] = in.nextInt();
        }
        for (int i = 0; i < L; i++){
            lotions[i][0] = in.nextInt();
            lotions[i][1] = in.nextInt();
        }
        System.out.println(solve(cows, lotions));
        in.close();
    }

    private static int solve(int[][] cows, int[][] lotions){
        Arrays.sort(cows, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                return o1[0] !=  o2[0] ? o1[0] - o2[0] : o1[1] - o2[1];
            }
        });
        Arrays.sort(lotions, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                return o1[0] - o2[0];
            }
        });

        Queue<int[]> queue = new PriorityQueue<>(new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                return o1[1] - o2[1];
            }
        });

        int cur = 0;
        int res = 0;
        for (int i = 0; i < lotions.length; i++){
            while (cur < cows.length && cows[cur][0] <= lotions[i][0]){
                queue.offer(cows[cur]);
                cur ++;
            }
            while (!queue.isEmpty() && lotions[i][1] != 0){
                if (queue.peek()[1] < lotions[i][0]){
                    queue.poll();
                }
                else{
                    res ++;
                    lotions[i][1]--;
                    queue.poll();
                }
            }
        }
        return res;
    }

}

有个优化小细节，代码精简很多。

while (!queue.isEmpty() && lotions[i][1] != 0){
    int max = queue.peek()[1]; queue.poll();
    if (max >= lotions[i][0]){
        res ++;
        lotions[i][1]--;
    }
}

POJ 2010: Moo University - Financial Aid

奶牛大学：奶大招生，从C头奶牛中招收N头。它们分别得分score_i，需要资助学费aid_i。希望新生所需资助不超过F，同时得分中位数最高。求此中位数。

思路：
用暴力的解法来做，有点类似累加和，来减少计算量。首先对奶牛的分数从小到大排序，所以只要知道当前坐标的[0,i-1]中N/2个元素之和的最小值和[i+1,C]的N/2个元素之和的最小值，就能通过暴力遍历来找到最大的中位数。

因为我们需要一直维护大小为N/2的最小元素集合，所以我们用堆来实现，这样，每次有新元素填入时，先offer进队列，然后再删除队首最大，就能始终保持大小为N/2的最小元素集合。

代码如下：

public class SolutionDay26_P2010 {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int N = in.nextInt();
        int C = in.nextInt();
        int F = in.nextInt();
        int[][] cast = new int[C][2];
        for (int i = 0; i < C; i++){
            cast[i][0] = in.nextInt();
            cast[i][1] = in.nextInt();
        }
        System.out.println(solve(cast, N, F));
        in.close();
    }

    private static int solve(int[][] cast, int N, int F){
        Arrays.sort(cast, (a, b) -> (a[0] - b[0]));

        int[] lower = new int[cast.length];
        int[] upper = new int[cast.length];
        Arrays.fill(lower, 1<<30);
        Arrays.fill(upper, 1<<30);
        int half = N / 2;
        {
            Queue<Integer> queue = new PriorityQueue<>((a,b) -> (b-a));
            int total = 0;
            for (int i = 0; i < cast.length; i++){
                if (queue.size() == half){
                    lower[i] = total;
                    queue.offer(cast[i][1]);
                    total += cast[i][1];
                    total -= queue.poll();
                }else{
                    total += cast[i][1];
                    queue.offer(cast[i][1]);
                }

            }
        }

        {
            Queue<Integer> queue = new PriorityQueue<>((a,b) -> (b-a));
            int total = 0;
            for (int i = cast.length - 1; i >=0; i--){
                if (queue.size() == half){
                    upper[i] = total;
                    queue.offer(cast[i][1]);
                    total += cast[i][1];
                    total -= queue.poll();
                }else{
                    total += cast[i][1];
                    queue.offer(cast[i][1]);
                }

            }
        }

        int res = -1;
        for (int i = cast.length-1; i >= 0; i--){
            if (lower[i] + cast[i][1] + upper[i] <= F){
                res = cast[i][0];
                break;
            }
        }
        return res;
    }
}