任务调度问题

任务调度问题

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

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

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

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

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

样例
Input

3 3
1 hello
2 world
10 test
Output

hello
hello
world

限制
0 ≤ n ≤ 4,000,000

0 ≤ m ≤ 2,000,000

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

不会有重名的任务

时间：2 sec

内存：512 MB

提示
优先级队列

#include<iostream>
#include<stdio.h>
#include<string.h>
#include<math.h>

using namespace std;
const long Maxlength = 4000005;
const long long  Max = pow(2,32);
const long long Size = pow(2,22);


struct FastlO //快速输入输出
{
	char inbuf[Size];
	char outbuf[Size];
	FastlO()
	{
		setvbuf(stdin,inbuf,_IOFBF,Size);
        setvbuf(stdout,outbuf,_IOFBF,Size);
	}
}IO;

typedef struct Task
{
    char TaskName[100];
    long long priority;

} Task;

Task task[Maxlength];

int GetLeftChild(int n)
{
    return n*2;
}

int GetRightChild(int n)
{
    return n*2+1;
}


void Swap(Task &a,Task &b)
{
    Task temp;
    temp = b;
    b = a;
    a = temp;
}

int Compare(Task a[],int i,int j)
{
    if(a[i].priority<a[j].priority||(a[i].priority == a[j].priority&&strcmp(a[i].TaskName,a[j].TaskName)<0))
    {
        return i;
    }
    else
    {
        return j;
    }
}

int Replace(int a,int n)
{
    int Parent = a;

    if(GetRightChild(a)<=n)
    {
        Parent=Compare(task,a,Compare(task,GetLeftChild(a),GetRightChild(a)));
    }


    else if(GetLeftChild(a)<=n)
    {
        Parent=Compare(task,a,GetLeftChild(a));
    }


    return Parent;
}


void SiftDown(int a,int n)
{
    int temp = Replace(a,n);

    while(temp!=a)
    {
        Swap(task[temp],task[a]);

        a=temp;

        temp=Replace(a,n);
    }
}
void Adjust(int n)
{
    for(int i = n/2 ; i>0 ; i--)
    {
        SiftDown(i,n);
    }
}
int  main()
{
    int n,m;
    cin>>n>>m;

    for(int i=1; i<=n; i++)
    {
        scanf("%lld %s",&task[i].priority,task[i].TaskName);
//        cin>>task[i].priority;
//        cin.get();
//        cin>>task[i].TaskName;
    }

    Adjust(n);

    for(int i=0; n!=0&&i<m; i++)
    {
        printf("%s\n",task[1].TaskName);
//        cout<<task[1].TaskName<<endl;

        task[1].priority *= 2;

        if(task[1].priority>=Max)
        {
            task[1] = task[n--];
        }
        SiftDown(1,n);
    }
}