算导3（调度问题）

2． A simple scheduling problem. We are given jobs j₁, j₂… j_n, all with known running times t₁, t₂… t_n, respectively. We have a single processor. What is the best way to schedule these jobs in order to minimize the average completion time. Assume that it is a nonpreemptive scheduling: once a job is started, it must run to completion. The following is an instance.

a)    (j₁, j₂, j₃, j₄) : (15，8，3，10)

  由于是非抢占式调度，所以应该尽量让时间短的作业先做，然后再让时间长的作业做。题目中的数字较少，所以很容易看出sum = (3 + (3 + 8) + (3 + 8 + 10) + (3 + 8 + 10 + 15))/4。这里我们使用堆进行排序，建立一个小顶堆（BuildMinHeap();），然后每次拿出小顶堆上的最小元素（HeapExtractMin(N);）。并使用sum中的公式就可以算出平均完成时间。堆排序的时间复杂度是O(nlgn)，其中 BuildMinHeap()的时间复杂度是O(n)，而 BuildMinHeap()的时间复杂度是O(lgn)。其中 HeapExtractMin(N)的时间复杂度是O(lgn)。当然也可以用快速排序等方法排好序，然后再进行时间调度，将平均完成时间降到最小。

#include <cstdlib>

#include <iostream>

using namespace std;

int N = 4;

int A[5]   = {0, 15, 8, 3, 10};

void MinHeapify(int i, int N)

{

      int l, r, small, swamp;

      l = 2 * i;

      r = 2 * i + 1;

      if(l <= N && A[l] < A[i])

          small = l;

      else small = i;

      if(r <= N && A[r] < A[small])

          small = r;

      if(small != i)

      {

              swamp = A[i];

              A[i] = A[small];

              A[small] = swamp;

              MinHeapify(small, N);

      }

     

}

void BuildMinHeap()

{

      for(int i = N/2; i >= 1; i--)

      {

              MinHeapify(i, N);

      }

}

int HeapExtractMin(int &N)

{

    int min = A[1];

    A[1] = A[N];

    cout << min << endl;

    --N;

    MinHeapify(1, N);

    return min;

}    

int main(int argc, char *argv[])

{

    int k;

    double sum;

    int i = 0;

    double t[N];

    BuildMinHeap();

    while(N)

    {

            t[i++] = HeapExtractMin(N);

    }

    for(int i = 0; i < 4; i++)

            cout << t[i] << " ";

    cout << endl;

    k = i;

    sum = ((t[0] * k + t[1] * (k - 1) + t[2] * (k - 2) + t[3] * (k - 3)) / k);

    printf("%.2f", sum);

    system("PAUSE");

    return EXIT_SUCCESS;

}