Job Processing[USACO]

这题用贪心法做的，每个任务都从现有的machine里面拿运行结束最早的机器里执行。

唯一需要写的是：用执行最快的arrJobDoneA 和 执行最慢的arrMachineDoneB相结合，第二快的A和第二慢的B相结合...最后这N个里面时间最长的那个就是所有任务全部执行完成的最长用时。

代码比较简单，如下：

/*
ID: zhangyc1
LANG: C++
TASK: job
*/
#include <fstream>
#include <iostream>
#include <cstdlib>
#include <cstring>
using namespace std;

ofstream fileout("job.out");

const int MAXJOBNUMBER = 1000, MAXMACHINENUMBER = 30;
int N, M1, M2;
int arrCostA[MAXJOBNUMBER], arrCostB[MAXJOBNUMBER];
int arrJobDoneA[MAXJOBNUMBER], arrJobDoneB[MAXJOBNUMBER], arrMachineDoneA[MAXMACHINENUMBER], arrMachineDoneB[MAXMACHINENUMBER];

void prepairData()
{
    ifstream filein("job.in");
    filein >> N >> M1 >> M2;
    for (int i = 0; i < M1; i++)
    {
        filein >> arrCostA[i];
    }

    for (int i = 0; i < M2; i++)
    {
        filein >> arrCostB[i];
    }

    filein.close();
    memset(arrMachineDoneA, 0, sizeof(arrMachineDoneA));
    memset(arrMachineDoneB, 0, sizeof(arrMachineDoneB));
    memset(arrJobDoneA, 0, sizeof(arrJobDoneA));
    memset(arrJobDoneB, 0, sizeof(arrJobDoneB));
}

void process()
{
    for (int i = 0; i < N; i++)
    // 每次选取最小的结束时间来完成本次任务。
    {
        int nMinPosA = 0;
        for (int j = 1; j < M1; j++)
        {
            if (arrMachineDoneA[j] + arrCostA[j] < arrMachineDoneA[nMinPosA] + arrCostA[nMinPosA])
                nMinPosA = j;
        }
        // 更新记录
        arrMachineDoneA[nMinPosA] += arrCostA[nMinPosA];

        arrJobDoneA[i] = arrMachineDoneA[nMinPosA];
    }
    // 因为任务是先执行A，后执行B，且arrJobDoneA本身有序，固输出最后一个即可。
    fileout << arrJobDoneA[N - 1] << " ";

    for (int i = 0; i < N; i++)
    // 每次选取最小的结束时间来完成本次任务。
    {
        int nMinPosB = 0;
        for (int j = 1; j < M2; j++)
        {
            if (arrMachineDoneB[j] + arrCostB[j] < arrMachineDoneB[nMinPosB] + arrCostB[nMinPosB])
                nMinPosB = j;
        }
        // 更新记录
        arrMachineDoneB[nMinPosB] += arrCostB[nMinPosB];

        arrJobDoneB[i] = arrMachineDoneB[nMinPosB];
    }

    // 用执行最快的arrJobDoneA 和 执行最慢的arrMachineDoneB相结合，第二快的A和第二慢的B相结合...
    int nMax = arrJobDoneA[0] + arrJobDoneB[N - 1];
    for (int i = 1; i < N; i++)
    {
        if (arrJobDoneA[i] + arrJobDoneB[N - i - 1] > nMax)
            nMax = arrJobDoneA[i] + arrJobDoneB[N - i - 1];
    }
    fileout << nMax << endl;
}

int main(){
    prepairData();
    process();
    fileout.close();    
    return 0;
}