PKU 2833 优先队列

原题http://poj.org/problem?id=2833

The Average

Time Limit: 6000MS   Memory Limit: 10000K
Total Submissions: 9423   Accepted: 2938
Case Time Limit: 4000MS

Description

In a speech contest, when a contestant finishes his speech, the judges will then grade his performance. The staff remove the highest grade and the lowest grade and compute the average of the rest as the contestant’s final grade. This is an easy problem because
usually there are only several judges.

Let’s consider a generalized form of the problem above. Given n positive integers, remove the greatest n1 ones and the least n2 ones,
and compute the average of the rest.

Input

The input consists of several test cases. Each test case consists two lines. The first line contains three integers n1n2 and n (1 ≤ n1n2 ≤
10, n1 + n2 < n ≤ 5,000,000) separate by a single space. The second line contains n positive integers ai (1
≤ ai ≤ 108 for all i s.t. 1 ≤ i ≤ n) separated by a single space. The last test case is followed
by three zeroes.

Output

For each test case, output the average rounded to six digits after decimal point in a separate line.

Sample Input

1 2 5
1 2 3 4 5
4 2 10
2121187 902 485 531 843 582 652 926 220 155
0 0 0

Sample Output

3.500000
562.500000

Hint

This problem has very large input data. scanf and printf are recommended for C++ I/O.

The memory limit might not allow you to store everything in the memory.

//直接做会超内存。所以用优先队列

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <limits.h>
#include <ctype.h>
#include <string.h>
#include <string>
#include <math.h>
#include <algorithm>
#include <iostream>
#include <queue>
#include <stack>
#include <deque>
#include <set>
#include <map>
using namespace std;

int main(){
    //priority_queue<int> q1;//从大到小输出
    //priority_queue<int,vector<int>,greater<int>> q2;//从小到大输出
    int max,min,n,i;
    int num;

    while(~scanf("%d%d%d",&max,&min,&n)){
        priority_queue<int>q1;
        priority_queue<int,vector<int>,greater<int> > q2;
        if(max==0 && min==0 && n==0){
            break;
        }
        __int64 sum = 0;
        for(i=1;i<=n;i++){
            scanf("%d",&num);
            sum+=num;
            q1.push(num);
            q2.push(num);
            if(q1.size() > min){
                q1.pop();
            }
            if(q2.size() > max){
                q2.pop();
            }
        }
        while(!q1.empty()){
            int mark = q1.top();
            sum-=mark;
            q1.pop();
        }
        while(!q2.empty()){
            int mark1 = q2.top();
            sum-=mark1;
            q2.pop();
        }
        double ans;
        ans = (sum+0.0)/(n-min-max);
        printf("%.6lf\n",ans);
    }

    return 0;
}
时间: 2024-10-12 19:40:22

PKU 2833 优先队列的相关文章

poj 2833 优先队列的应用

题目有提示内存限制,所以自然会想到用优先队列来维护前k大和前k小. 1 #include <iostream> 2 #include <cstring> 3 #include <cstdio> 4 #include <queue> 5 using namespace std; 6 7 typedef long long ll; 8 priority_queue<int, vector<int>, greater<int> >

vijos 1016 北京2008的挂钟

北京2008的挂钟 描述 在2008北京奥运会雄伟的主会场的墙上,挂着如上图所示的3*3的九个挂钟(一开始指针即时针指向的位置请根据输入数据调整).然而此次奥运会给与了大家一个机会,去用最少的移动操作改变上面的挂钟的时间全部为12点正(我们只考虑时针).然而每一次操作并不是任意的,我们必须按照下面给出的列表对于挂钟进行改变.每一次操作我们给而且必须给指定的操作挂钟进行,每一个挂钟顺时针转动90度.列表如下: 操作 指定的操作挂钟1 ABDE2 ABC3 BCEF4 ADG5 BDEFH6 CFI

POJ 1862 &amp; ZOJ 1543 Stripies(贪心 | 优先队列)

题目链接: PKU:http://poj.org/problem?id=1862 ZJU:http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemId=543 Description Our chemical biologists have invented a new very useful form of life called stripies (in fact, they were first called in Russian -

51nod1428(优先队列)

题目链接:http://www.51nod.com/onlineJudge/questionCode.html#!problemId=1428 题意:中文题诶- 思路:贪心 问最少要多少教室就是求最多有多少个时间段产生了交集咯.我们先用结构体存储区间并将其按照左端点升序排列,若左端点相同则按右端点升序排列. 接下来遍历所有区间,并维护一个优先队列,其中存储区间右端点值.对于当前区间,我们将优先队列中所有比当前区间左端点小的元素删除(因为其所在区间不会与当前区间相交嘛),然后再将当前区间的右端点加

优先队列实现哈弗曼最小权值

建立哈弗曼树要求我们每次都选频率权值最小的点构成节点,即权值小的点在树的深处,权值大的点在树的浅处,根据节点选择的特点,我们可以把节点的值放在优先队列中,包括新形成的节点. 我们先定义优先队列的优先级别. 1 struct cmp 2 { 3 bool operator()(const int &a,const int &b) 4 { 5 return a>b; 6 } 7 };//最小值优先出队 然后就是实现的整个程序. #include<stdio.h> #inclu

NYOJ 284 坦克大战 &amp;&amp; POJ 2312 Battle City (广搜+优先队列)

链接:click here~~ 题意: 描述 Many of us had played the game "Battle city" in our childhood, and some people (like me) even often play it on computer now. What we are discussing is a simple edition of this game. Given a map that consists of empty space

hdu 4006 The kth great number(优先队列)

The kth great number Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65768/65768 K (Java/Others) Total Submission(s): 6982    Accepted Submission(s): 2837 Problem Description Xiao Ming and Xiao Bao are playing a simple Numbers game. In a roun

优先队列(堆)

一.优先队列的一些简单的实现: 1. 使用一个简单的链表在表头以O(1) 执行插入操作,并遍历该链表以删除最小元,这需要O(N) 的时间. 2. 始终让表保持有序状态:这使得插入代价高昂(O(N)), 而删除代价低廉(O(1)).基于删除最小元的操作从不多于插入操作的事实,因此,前者是更好地想法. 3. 使用二叉查找树,它对这两种操作的平均运行时间是O(logN).尽管插入是随机的,而删除不是,但这个结论还是成立的.由于删除的唯一元素是最小元.反复除去左子树中的节点似乎损害树的平衡,使得右子树加

优先队列比较符重载

#include <iostream> #include <queue> using namespace std; struct Node{ int x, y; friend bool operator<(Node a, Node b){ return a.x > b.x; //x最小的节点在队首 } }; int main(){ priority_queue<Node> PQ; Node temp = {2, 3}; PQ.push(temp); temp