USACO Job Processing 解题报告

这道题目前还是没能完全理解，只是明白大致思路。对于type A, 最好的策略是greedy,即对每个job选择预期结束时间最短的machine。这样，对于job从1到N，1将最早结束，N将最晚结束。对于type B, 我们的目标是让所有的job一起结束，这样才能使得最终的结束时间最短，因为结束时间是由结束最晚的job决定的。为了达到这个目标，具体做法是让最晚结束type A的job最先选。选择的方法和type A一样，都是选择预期结束时间最短的machine。这里可以想象成一个从后往前倒着选的过程。

/*
ID: thestor1
LANG: C++
TASK: job
*/
#include <iostream>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <climits>
#include <cassert>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <algorithm>

using namespace std;

int main()
{
FILE *fin  = fopen("job.in", "r");
FILE *fout = fopen("job.out", "w");

int N, M1, M2;
fscanf(fin, "%d", &N);
fscanf(fin, "%d", &M1);
fscanf(fin, "%d", &M2);

vector<int> ma_time(M1), mb_time(M2);
for (int i = 0; i < M1; ++i)
{
fscanf(fin, "%d", &ma_time[i]);
}

for (int i = 0; i < M2; ++i)
{
fscanf(fin, "%d", &mb_time[i]);
}

std::vector<int> finishA(N, 0), finishB(N, 0);
std::vector<int> tasksA(M1, 0), tasksB(M2, 0);

for (int i = 0; i < N; ++i)
{
int mintime = -1, minj = -1;
for (int j = 0; j < M1; ++j)
{
if (mintime < 0 || (tasksA[j] + 1) * ma_time[j] < mintime)
{
mintime = (tasksA[j] + 1) * ma_time[j];
minj = j;
}
}
tasksA[minj]++;
finishA[i] = mintime;
}

for (int i = N - 1; i >= 0; --i)
{
int mintime = -1, minj = -1;
for (int j = 0; j < M2; ++j)
{
if (mintime < 0 || (tasksB[j] + 1) * mb_time[j] < mintime)
{
mintime = (tasksB[j] + 1) * mb_time[j];
minj = j;
}
}
tasksB[minj]++;
finishB[i] = mintime;
}

int maxtime = 0;
for (int i = 0; i < N; ++i)
{
if (finishA[i] + finishB[i] > maxtime)
{
maxtime = finishA[i] + finishB[i];
}
}

// cout<<"[debug]maxtime for A: "<<finishA[N - 1]<<endl;
// cout<<"[debug]maxtime for A & B: "<<maxtime<<endl;
fprintf(fout, "%d %d\n", finishA[N - 1], maxtime);
fclose(fin);
fclose(fout);
return 0;
}