清华OJ——任务调度

描述

某高性能计算集群（HPC cluster）采用的任务调度器与众不同。为简化起见，假定该集群不支持多任务同时执行，故同一时刻只有单个任务处于执行状态。初始状态下，每个任务都由称作优先级数的一个整数指定优先级，该数值越小优先级越高；若优先级数相等，则任务名ASCII字典顺序低者优先。此后，CPU等资源总是被优先级数最小的任务占用；每一任务计算完毕，再选取优先级数最小下一任务。不过，这里的任务在计算结束后通常并不立即退出，而是将优先级数加倍（加倍计算所需的时间可以忽略）并继续参与调度；只有在优先级数不小于2^32时，才真正退出

你的任务是，根据初始优先级设置，按照上述调度原则，预测一批计算任务的执行序列。

输入

第一行为以空格分隔的两个整数n和m，n为初始时的任务总数，m为所预测的任务执行序列长度，每行末尾有一个换行符

以下n行分别包含一个整数和一个由不超过8个小写字母和数字组成的字符串。前者为任务的初始优先级数，后者为任务名。数字和字符串之间以空格分隔

输出

最多m行，各含一个字符串。按执行次序分别给出执行序列中前m个任务的名称，若执行序列少于m，那么输出调度器的任务处理完毕前的所有任务即可。

样例

见英文题面

限制

0 ≤ n ≤ 4,000,000

0 ≤ m ≤ 2,000,000

0 < 每个任务的初始优先级 < 2^32

不会有重名的任务

时间：2 sec

内存：512 MB

提示

优先级队列

思路：实际上就是手动实现一个堆，完成建堆、插入、删除操作。代码如下：

#include<cstdio>
#include<iostream>
#include<cstring>
#define check(i, n) (i > 0 && i < n)
using namespace std;
typedef long long ll;
const int N = 4e6 + 5;
const ll MAXN = 1ll << 32;
int n, m;
struct node
{
    ll priority;
    char name[10];
    bool operator<(const node t){
        if(this->priority != t.priority) return this->priority < t.priority;
        if(strcmp(this->name, t.name) < 0) return true;     //这个地方，C标准并没有规定小于返回-1，之前用 ==-1做判断WR了，调试了半天
        return false;
    }
};

//堆，物理上是数组，逻辑上是完全二叉树
node h[N];

//三者取最小
int min_in_three(int i){
    int lc = (i << 1) + 1, rc = (i + 1) << 1;
    int min = i;
    if(check(lc, n) && h[lc] < h[min]) min = lc;
    if(check(rc, n) && h[rc] < h[min]) min = rc;
    return min;
}

//从i结点下滤直至叶子
void precolatedown(int n, int i){
    int j;
    while(i != (j = min_in_three(i))){
        swap(h[i], h[j]);
        i = j;
    }
}

//从t结点上滤直至根
void precolateup(int t){
    while(t > 0){
        int p = (t - 1) >> 1;
        if(h[t] < h[p]){
            swap(h[p], h[t]);
            t = p;
        }
        else break;
    }
}

//删除堆顶元素，返回其值
node delmax(){
    node t = h[0];
    h[0] = h[--n];
    precolatedown(n, 0);
    return t;
}

//堆中插入一个元素t
void insert(node t){
    h[n++] = t;
    precolateup(n - 1);
}


void heapification(int n){
    //floyed建堆法，自下而上的下滤过程，复杂度O(n)
    for(int i = (n >> 1) - 1; i >= 0; i--)
        precolatedown(n, i);

    //自上而下的上滤过程，复杂度O(nlgn)
    // for(int i = 0; i < n; i++)
    //     precolateup(i);
}


int main(){
    scanf("%d%d", &n, &m);

    for(int i = 0; i < n; i++) scanf("%lld %s", &h[i].priority, &h[i].name);

    heapification(n);

    while(m-- && n){
        node t = delmax();
        printf("%s\n", t.name);
        t.priority *= 2;
        if(t.priority < MAXN) insert(t);
    }

    return 0;

}

效率分析：

建堆过程采用floyed建堆法，自下而上的下滤过程，复杂度O(n)，插入和删除操作主要复杂度来自上滤precolateup和下滤precolatedown过程，复杂度均为O(lgn)。整个程序无非是建堆、删除结点、插入结点操作，最坏情况下，复杂度O(n + mlgn)。

如果建堆过程采用自上而下的上滤过程，复杂度O(nlgn)，总的复杂度为O((n+m)lgn)。