poj1193

//============================================================================
// Name        : 1193.cpp
// Author      : 
// Version     :
// Copyright   : Your copyright notice
// Description : Hello World in C++, Ansi-style
//============================================================================

#include <iostream>
#include <queue>
using namespace std;

typedef struct node {
	int start;
	int end;
	int size;
	struct node* pre;
	struct node* next;
} Node;

typedef struct event {
	int t;
	int m;
	int p;
	int index;
	Node *node;

	friend bool operator<(const struct event& a, const struct event &b) {
		if (a.t != b.t)
			return a.t > b.t;
		else if (a.node != b.node)
			return a.node < b.node;
		else
			return a.index > b.index;

	}
} Event;

class Area {
private:
	Node * first;
public:
	Area(int size) {
		first = new Node;
		first->start = 0;
		first->end = size;
		first->size = size;
		first->pre = NULL;
		first->next = NULL;
	}

	Node* devide(int m) {
		Node * p = first;
		while (p && p->size < m) {
			p = p->next;
		}
		if (p == NULL) {
			return NULL;
		} else if (p->size == m) {
			p->size = 0;
			return p;
		} else {
			Node* n = new Node;
			n->start = p->start;
			n->size = 0;
			n->end = n->start + m;

			p->start = n->end;
			p->size -= m;

			n->pre = p->pre;
			n->next = p;

			if (first == p) {
				first = n;
			} else {
				p->pre->next = n;
			}
			p->pre = n;
			return n;
		}
	}

	void removeNode(Node * n) {
		n->size = n->end - n->start;
		if (n->next && n->next->size > 0) {
			Node * p = n->next;
			n->end = p->end;
			n->size += p->size;

			n->next = p->next;
			if (n->next) {
				n->next->pre = n;
			}
			delete p;
		}

		if (n->pre && n->pre->size > 0) {
			Node *p = n->pre;
			n->start = p->start;
			n->size += p->size;

			n->pre = p->pre;
			if (p == first) {
				first = n;
			} else {
				p->pre->next = n;
			}
			delete p;
		}
	}
};

Event evs[10001];
int count;

int main() {
	int n;
	cin >> n;
	count = 0;
	while (1) {
		cin >> evs[count].t >> evs[count].m >> evs[count].p;
		if (evs[count].t == 0 && evs[count].m == 0 && evs[count].p == 0) {
			break;
		}
		evs[count].node = NULL;
		evs[count].index = count + 2;
		count++;
	}
	Area area(n);
	priority_queue<Event> qs;
	for (int i = 0; i < count; i++)
		qs.push(evs[i]);
	queue<Event> waits;
	int max = 0;
	int wn = 0;

	while (qs.size() || waits.size()) {
		Event et = qs.top();
		qs.pop();
		if (et.node) {
			area.removeNode(et.node);
			while (qs.size()) {
				Event et2 = qs.top();
				if (et2.node && et2.t == et.t) {
					area.removeNode(et2.node);
					qs.pop();
				} else {
					break;
				}
			}
			while (waits.size()) {
				Event add = waits.front();
				Node * nd = area.devide(add.m);
				if (nd) {
					add.t = add.p + et.t;
					if (max < add.t)
						max = add.t;
					waits.pop();
					add.node = nd;
					qs.push(add);
				} else {
					break;
				}
			}
		} else {
			Node * nd = area.devide(et.m);
			if (nd) {
				et.t += et.p;
				if (max < et.t)
					max = et.t;
				et.node = nd;
				qs.push(et);
			} else {
				waits.push(et);
				wn++;
			}
		}
	}
	cout << max << endl;
	cout << wn << endl;
	return 0;
}