POJ 2010 Moo University - Financial Aid

/*
要看清楚题是求N个所选Cal中Score中最大的中位数.那么很容易想到将N以中间的分数
折半分别求其两边具有最小的aid和的N/2个cal.
(1)所以首先可以对输入按照分数进行排序,然后利用堆处理.
(2)先让前N/2个cal进堆并统计aid
的总和curtotalaid,然后依次对第N/2 ~ C - N/2个cal进行处理.每处理一个cal时,将curtotalaid
存入当前cal的lval中，并从堆中弹出具有最大aid值的cal,并将这个aid值和当前cal的aid值比较,
哪个更小就将那个插入堆中,同时更新curtotalaid.因此每次循环结束时,堆中都有N/2个元素且
curtotalaid就是这N/2个元素aid值的和.每个cal i的lval值的物理含义是,从0 ～ i- 2个cal中
具有最小aid总和的N/2个cal aid值的总和.
(3)用同样的方法计算rval,只不过这次需要首先将C - N/2 ~ C个元素入堆,然后依次处理
C - N/2 - 1 ~ N/2个cal以计算其rval值
(4)最后遍历第N/2 ~ C - N/2 -1个cal计算其lval +  rval + aid的值,如果这个值小于F则是满足
要求的,然后去所有这些满足要求的cal的score就是我们需要求的中位数了

这个算法的时间复杂度为
O(ClgC)(排序) + O(2 * ClgC)(2次扫描的堆操作) + O(C)(最后的扫描) = O(ClgC)
堆是自己手写的
*/
#include <iostream>
#include <algorithm>
#define MAX_N 20002
#define MAX_C 100010
using namespace std;

//堆数组
int heap[MAX_N + 1], size;
int N, C, F;

//存每个cal的相关信息
struct cal
{
    int aid, score, lval, rval;
}cals[MAX_C + 1];

bool compare(const cal &c1, const cal &c2)
{
    return c1.score <= c2.score;
}

void swap(int &v1, int &v2)
{
    int temp = v1;
    v1 = v2;
    v2 = temp;
}

//从堆中下标为p的位置开始维持堆的性质
void maxHeapify(int p)
{
    int l = p * 2, r = p * 2 + 1, maxPos = p;
    if(l <= size && cals[heap[l]].aid > cals[heap[maxPos]].aid) maxPos = l;
    if(r <= size && cals[heap[r]].aid > cals[heap[maxPos]].aid) maxPos = r;

    if(maxPos != p)
    {
        swap(heap[p], heap[maxPos]);
        maxHeapify(maxPos);
    }
}

//从堆中弹出最大值
int popMaxHeap()
{
    if(size <= 0) return -1;
    else
    {
        int temp = heap[1];
        heap[1] = heap[size];
        size--;
        maxHeapify(1);
        return temp;
    }
}

//将p值插入堆中
void insert(int p)
{
    size++;
    heap[size] = p;
    int tempp = size;
    while(tempp > 1 && cals[heap[tempp / 2]].aid < cals[heap[tempp]].aid)
    {
        swap(heap[tempp], heap[tempp / 2]);
        tempp /= 2;
    }
}

int main()
{
    int i;
    scanf("%d%d%d", &N, &C, &F);
    for(i = 0; i < C; i++) scanf("%d%d", &cals[i].score, &cals[i].aid);
   
    //先按照score进行排序
    sort(cals, cals + C, compare);

    size = 0;
    int curTotalAid = 0;
    //将前N/2个cal入堆并统计aid的总和
    for(i = 0; i < N / 2; i++)
    {
        insert(i);
        curTotalAid += cals[i].aid;
    }

    //依次处理后续元素,统计其lval值
    for(i = N / 2; i < C - N / 2; i++)
    {
        cals[i].lval = curTotalAid;
        int maxpos = popMaxHeap();
        if(cals[maxpos].aid > cals[i].aid)
        {
            insert(i);
            curTotalAid = curTotalAid - cals[maxpos].aid + cals[i].aid;
        }
        else insert(maxpos);
    }

    size = curTotalAid = 0;
    //将后N/2个cal入堆并统计其aid总和
    for(i = C - N / 2; i < C; i++)
    {
        insert(i);
        curTotalAid += cals[i].aid;
    }

    //从后往前扫描中间的cal并计算其rval值
    for(i = C - N / 2 - 1; i >= N / 2; i--)
    {
        cals[i].rval = curTotalAid;
        int maxpos = popMaxHeap();
        if(cals[maxpos].aid > cals[i].aid)
        {
            insert(i);
            curTotalAid = curTotalAid - cals[maxpos].aid + cals[i].aid;
        }
        else insert(maxpos);
    }

    int maxScore = 0;
    //扫描中间的所有cal寻找满足最大条件的中位分数
    for(i = N / 2; i < C - N / 2; i++)
        if(cals[i].lval + cals[i].rval + cals[i].aid <= F && cals[i].score > maxScore)
            maxScore = cals[i].score;
    if(maxScore == 0) printf("-1/n");
    else printf("%d/n", maxScore);
    return 0;
}