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;  
}