多机调度问题（非抢先调度）

一、 问题描述

一个工程有m台一模一样的机器，我们有n个任务需要处理，任务i的处理时间为ti。所谓调度是指按任务在机器上的运行时间分配任务，使得：
（1）一台机器在同一时间只能处理一个任务；
（2）一个任务不能同时在两台机器上处理；
（3）一个任务i的处理时间是ti个时间单位。
并求出完成所有任务所需要的最短时间。

二、求解思路

采用最长处理时间任务优先的贪心策略:
当n≤m时, 只要将机器i的[0, ti]时间区间分配给任务i即可；
当n>m时, 将n个任务按照其所需的处理时间从大到小排序，然后依次将任务分配给空闲的机器。

三、具体代码

（1）MinHeap.h

template<class T>
class MinHeap
{
private:
    // 元素数组，0号位置也存储元素
    T *heap;    
    // 目前元素个数
    int currentSize;
    // 可容纳的最多元素个数
    int maxSize;

    // 自上往下调整，使关键字小的字节在上
    void FilterDown(const int start, const int end);
    // 自下往上调整
    void FilterUp(int start);

public:
    MinHeap(int n = 1000);
    ~MinHeap();

    // 插入元素
    bool Insert(const T &x);
    // 获取最小元素
    T GetMin();
    // 删除最小元素
    T RemoveMin();

    bool IsEmpty() const;
    bool IsFull() const;
    void clear();
};

template<class T>
MinHeap<T>::MinHeap(int n)
{
    maxSize = n;
    heap = new T[maxSize];
    currentSize = 0;
}

template<class T>
MinHeap<T>::~MinHeap()
{
    delete [] heap;
}

// 自下往上调整
template<class T>
void MinHeap<T>::FilterUp(int start)
{
    // i 指向 j 的双亲节点
    int j = start, i = (j - 1)/2;
    T temp = heap[j];

    while(j > 0)
    {
        if(heap[i] <= temp)
            break;
        else
        {
            heap[j] = heap[i];
            j = i;
            i = (i - 1)/2;
        }
    }
    heap[j] = temp;
}

// 自下往上调整，使关键字小的节点在上
template<class T>