uva 1422 - Processor(二分+优先队列）

题目链接：uva 1422 - Processor

题目大意：有一个机器要处理一些问题，给出这些问题可以开始的时间和必须完成的时间，以及任务的工作量，问说机器必须以最少每秒多少得工作量才能完成这些任务。

解题思路：二分答案，答案的上限是MaxWork * MaxN（全在一秒内完成）。然后就是判断说在c的工作量小是否能完成任务。因为处理一个问题的时间可以不连续，所以给解题增加了难度。

现将任务按照开始的时间从小到大排序，然后枚举时间区间。开始时间比当前枚举时间小的话入队。

队列用优先队列,结束时间较小的优先满足。

当队列中的第一个元素的结束时间小于当前枚举时间的起始值时，返回false，因为不会再有时间片可以用于解决该问题。

#include <stdio.h>
#include <string.h>
#include <queue>
#include <algorithm>

using namespace std;

const int N = 10005;

struct state {
	int x, y, w, d;
	state() { d = 0; }
	friend bool operator < (state a, state b) {
		return a.y > b.y;
	}
}s[N];
int n, l, r;

bool cmp(const state& a, const state& b) {
	return a.x < b.x;
}

void init() {
	l = 0; r = 10000000;

	scanf("%d", &n);
	for (int i = 0; i < n; i++)
		scanf("%d%d%d", &s[i].x, &s[i].y, &s[i].w);
	sort(s, s + n, cmp);
}

bool judge(int c) {
	priority_queue<state> q;
	int cnt = 0, t = 0;
	state k;

	for (int i = 1; i <= 20000; i++) {
		if ( !q.empty()) {
			k = q.top();
			if (k.y + 1 <= i) return false;
		}

		while (t < n) {
			if (s[t].x < i) {
				q.push(s[t]);
				t++;
			} else break;
		}

		int cur = c;
		while (cur && !q.empty()) {
			k = q.top(); q.pop();
			int now = min(cur, k.w - k.d);
			k.d += now; cur -= now;

			if (k.w - k.d) {
				q.push(k);
			} else {
				cnt++;
			}
		}

		if (cnt == n) return true;
	}
	return false;
}

int solve() {
	while (true) {
		if (r - l == 1) break;

		int mid = (l + r) / 2;

		if (judge(mid)) r = mid;
		else l = mid;
	}
	return r;
}

int main () {
	int cas;
	scanf("%d", &cas);
	while (cas--) {
		init();
		printf("%d\n", solve());
	}
	return 0;
}