贪心算法之多机调度问题

问题描述：

设有n个独立的作业{1,2,…, n }，由m台相同的机器进行加工处理。作业i所需的处理时间为i t 。现约定，每个作业均可在任何一台机器上加工处理，但未完工前不允许中断处理。作业不能拆分成更小的子作业。多机调度问题要求给出一种作业调度方案，使所给的n个作业在尽可能短的时间内由m台机器加工处理完成。

这个问题是NP完全问题，到目前为止还没有有效的解法。对于这一类问题,用贪心选择策略有时可以设计出较好的近似算法。采用最长处理时间作业优先的贪心选择策略可以设计出解多机调度问题的较好的近似算法。按此策略，当n <= m时，只要将机器i的[0, i t ]时间区
间分配给作业i即可。当n > m时，首先将n个作业依其所需的处理时间从大到小排序。然后依此顺序将作业分配给空闲的处理机。

例如，设7个独立作业{1,2,3,4,5,6,7}由3台机器M1，M2和M3加工处理。各作业所需的处理时间分别为{2,14,4,16,6,5,3}。按算法greedy产生的作业调度如下图所示，所需的加工时间为17。

//多机调度问题
#include <iostream>
using namespace std;

template <typename Type>
void Swap(Type& x, Type& y)
{
    Type temp = x;
    x = y;
    y = temp;
}

template <typename Type>
void Sort(Type *a, int n)
{
    //对a[1..n]中n个元素进行排序(选择排序)
    for(int i = 1; i < n; i++)
    {
        int k = i;
        for(int j = i+1; j <= n; j++)
        {
            //找出第i小的元素
            if(a[j] < a[k]){
                k = j;
            }
        }
        Swap(a[i],a[k]);
    }
}

template <typename Type>
class MinHeap
{
    public:
        MinHeap(int ms);
        ~MinHeap();
        void Insert(const Type& x);
        void DeleteMin(Type& x);
    protected:
        void FilterDown();      //自顶向下构造堆
        void FilterUp();        //自底向上构造堆
    private:
        Type *heap;
        int length;
};

//初始化一个空堆
template <typename Type>
MinHeap<Type> :: MinHeap(int m)
{
    heap = new Type[m+1];
    length = 0;
}

template <typename Type>
void MinHeap<Type> :: Insert(const Type& x)
{
    heap[++length] = x;
    FilterUp();
}

template <typename Type>
void MinHeap<Type> :: FilterUp()
{
    //自底向上进行调整
    int  i = length, j = i/2;       //父节点的编号
    Type temp = heap[i];
    while(i > 1)
    {
        if(temp >= heap[j]){
            break;              //找到了相应的位置
        }else {
            heap[i] = heap[j];
            i = j;
            j = i/2;
        }
    }
    heap[i] = temp;
}

template <typename Type>
void MinHeap<Type> :: DeleteMin(Type& x)
{
    x = heap[1];
    heap[1] = heap[length];
    length--;
    FilterDown();
}

template <typename Type>
void MinHeap<Type> :: FilterDown()
{
    int i = 1, j = i*2;
    Type temp = heap[i];
    while(j <= length)
    {
        if(j < length && heap[j] > heap[j+1]){
            j++;        //如果左右子树都存在，找出最小者，用j标记
        }
        if(temp < heap[j]){
            break;       //找到了相应的位置
        } else {
            heap[i] = heap[j];
            i = j;
            j = 2*i;
        }
    }
    heap[i] = temp;
}

template <typename Type>
MinHeap<Type> :: ~MinHeap()
{
    delete[] heap;
}

class JobNode{
    friend void Greedy(JobNode* , int ,int );
    friend int main(void);
    public:
        operator int()  const{return time;}
    private:
        int ID,             //作业编号
        time;               //对应作业处理时间
};

class MachineNode{
    friend void Greedy(JobNode* ,int ,int );
    public:
        operator int() const{return avail;}
    private:
        int ID,             //作业编号
        avail;              //
};

//template <typename Type>
void Greedy(JobNode a[], int n, int m)
{
    if(n <= m){
        cout<<"为每个作业分配一台机器."<<endl;
        return ;
    }
    Sort(a,n);
    MinHeap <MachineNode> H(m);
    MachineNode x;
    for(int i = 1; i <= m; i++){
        x.avail = 0;
        x.ID = i;
        H.Insert(x);
    }

    for(int i = n; i >= 1; i--){
        H.DeleteMin(x);
        cout<<"将机器"<<x.ID<<"从"<<x.avail<<"到"<<(x.avail + a[i].time)<<"的时间段分配给作业"<<a[i].ID<<endl;
        x.avail += a[i].time;
        H.Insert(x);
    }
}

int main()
{
    int n;              //作业个数
    int m;              //机器台数
    cout<<"请输入作业个数n和机器台数m:"<<endl;
    cin>>n>>m;
    JobNode *b = new JobNode[n+1];
    cout<<"请输入对应作业号1-"<<n<<"的处理时间time:"<<endl;
    for(int i = 1; i <= n; i++)
    {
        b[i].ID = i;
        cin>>b[i].time;
    }
    Greedy(b,n,m);
    delete[] b;
	return 0;
}