Problem:
Problem E: School Excursion

春、それは修学旅行の時期である。
会津大学附属小学校（会津大小）でも、来年度の修学旅行の計画が建てられていた。
修学旅行は電車で移動することが伝統になっている。
会津若松市内では電車を利用する機会が少ないためだ。

しかし、学校に届いたある苦情により教員たちは頭を悩ませていた。
それは、「ある駅で大人数で乗り換えを行っていたので、その駅を利用する他の乗客に迷惑であった」という内容だった。
とくに、電車を降りたあとホームからの通路で大混雑してしまったという。

それは近年、会津大小の生徒数が急上昇しているからであった。
その原因は日本において競技プログラミングが大流行し、
小学校から競技プログラマーを養成するための訓練を行っている会津大小に生徒が集まったからである。

会津大小競技プログラミング部長であるあなたは、修学旅行を楽しみにしている。
修学旅行を成功させたいあなたは教員たちに提案をした。
「クラスごとに行動して、同じ駅に同時に到着しないようにしましょう！！　競技プログラミングの知識を応用すれば簡単です！！」

複数のクラスが同時に同じ駅に到着することがないように移動するとき（同じ駅に複数のクラスが滞在することは可能）、
出発する駅から目的地まで到達できる最大のクラス数を求め、そのときの最小の運賃を求めるプログラムをつくりなさい。
ただし、ある駅で同時に到着する電車と発車する電車が存在する場合、乗り継ぎが可能である。つまり、乗り継ぎに要する時間は無視して良い。

Input

入力は複数のデータセットから構成される。
データセットの数は20個以下である。
各データセットの形式は次に示す通りである。

n
m1
x1,1 y1,1 c1,1
x1,2 y1,2 c1,2
...
x1,m1 y1,m1 c1,m1
m2
x2,1 y2,1 c2,1
x2,2 y2,2 c2,2
...
x2,m2 y2,m2 c2,m2
...
mn-1
xn-1,1 yn-1,1 cn-1,1
xn-1,2 yn-1,2 cn-1,2
...
xn-1,m2 yn-1,m2 cn-1,m2
g

n( 2 ≤ n ≤ 100)は駅の数を表す。
駅の数は出発する駅と目的地の駅、乗り換えする駅を含む。
駅は出発する駅を1番目、最初に乗り換える駅を2番目の駅と数え、目的地をn番目の駅とする。
miはi番目の駅からi+1番目の駅への電車の数を表す。
mi(1 ≤ m ≤ 20)個の電車の情報が続く。
xi,j yi,j ci,j
はi番目の駅からi+1番目の駅に向かう電車の出発時刻(xi,j)到着時刻(yi,j)運賃(ci,j)を表す。
(0 ≤ xi,j, yi,j ≤ 200000 かつ xi,j ≤ yi,j)
(1 ≤ ci,j ≤ 1000)

その後g(1≤ g ≤ 10)が続く。
gは修学旅行に参加するクラス数を表す。
与えられる数（n,m,x,y,c,g)はすべて整数である。
入力の終了はひとつの0を含む１行で示される。

Output

一行に到着可能なクラス数とそのときの最小運賃をこの順に出力せよ。
もし、ただ一つのクラスも到着できない場合は0 0を出力せよ。

Sample Input

2
4
1 2 10
2 2 5
1 3 20
2 3 10
10
3
2
1 2 5
0 3 4
3
10 11 100
2 12 2
12 12 3
10
0

Sample Output

2 15
2 111

Solution in C (judge verdict: Wrong Answer)

// AOJ 1088 School Excursion
// 2018.3.7 bal4u

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define QMAX 10005
typedef struct { int t, s; } QUE;
QUE que[QMAX]; int qsize;

#define PARENT(i) ((i)>>1)
#define LEFT(i)   ((i)<<1)
#define RIGHT(i)  (((i)<<1)+1)

void min_heapify(int i)
{
	int l, r, min;
	QUE qt;

	l = LEFT(i), r = RIGHT(i);
	if (l < qsize && que[l].t < que[i].t) min = l; else min = i;
	if (r < qsize && que[r].t < que[min].t) min = r;
	if (min != i) {
		qt = que[i], que[i] = que[min], que[min] = qt;
		min_heapify(min);
	}
}

void deq()
{
	que[0] = que[--qsize];
	min_heapify(0);
}

void enq(int s, int t)
{
	int i, min;
	QUE qt;

	i = qsize++;
	que[i].s = s, que[i].t = t;
	while (i > 0 && que[min = PARENT(i)].t > que[i].t) {
		qt = que[i], que[i] = que[min], que[min] = qt;
		i = min;
	}
}

#define INF 0x01010101
#define MAX 4004
typedef struct { int to, rev; int cap, cost; } E;
E *edge[MAX]; int hi[MAX], lim[MAX];
int V;				// 頂点数
int potential[MAX], min_cost[MAX], prevv[MAX], preve[MAX];

void check_lim(int a)
{
	if (hi[a] < lim[a]) return;
	if (lim[a] == 0) {
		lim[a] = 4, hi[a] = 0;
		edge[a] = malloc(sizeof(E) *lim[a]);
	} else if (hi[a] == lim[a]) {
		int k = lim[a];
		if (k > 512) k = 512;
		lim[a] += k;
		edge[a] = realloc(edge[a], sizeof(E) *lim[a]);
	}
}

void add_edge(int from, int to, int cap, int cost)
{
	int f, t;
	E *ep;

	check_lim(from), check_lim(to);
	f = hi[from]++, t = hi[to]++;
	ep = &edge[from][f], ep->to = to, ep->cap = cap, ep->cost = cost, ep->rev = t; 
	ep = &edge[to][t], ep->to = from, ep->cap = 0, ep->cost = -cost, ep->rev = f;
}

int minCostFlow(int *f, int S, int T, int F)
{
	int i, s, ns, t, nt, ret;
	E *ep;

	ret = 0;
	memset(potential, 0, V << 2);
  
    while (F > 0) {
		memset(min_cost, INF, V << 2);
		qsize = 0;
		enq(S, 0), min_cost[S] = 0;
  
		while (qsize) {
			s = que[0].s, t = que[0].t, deq();
			if (min_cost[s] < t) continue;

			for (i = 0; i < hi[s]; i++) {
				ep = &edge[s][i], ns = ep->to;
				nt = t + ep->cost + potential[s] - potential[ns];
				if(ep->cap > 0 && min_cost[ns] > nt) {
					min_cost[ns] = nt;
					prevv[ns] = s, preve[ns] = i;
					enq(ns, nt);
				}
			}
		}
		if (min_cost[T] == INF) { *f = F; return ret; }
		for (s = 0; s < V; s++) potential[s] += min_cost[s];

		t = F;
		for (s = T; s != S; s = prevv[s]) {
			ep = &edge[prevv[s]][preve[s]];
			if (t > ep->cap) t = ep->cap;
		}
		F -= t;

		ret += t * potential[T];
		for (s = T; s != S; s = prevv[s]) {
			ep = &edge[prevv[s]][preve[s]];
			ep->cap -= t;
			edge[s][ep->rev].cap += t;
		}
    }
	*f = 0;
	return ret;
}

//#define getchar_unlocked()  getchar()
int in()
{
	int n = 0;
	int c = getchar_unlocked();
	do n = 10*n + (c & 0xf), c = getchar_unlocked();
	while (c >= '0');
	return n;
}

int  tm[4004];		// time

int main()
{
	int n, i, j, k, m, x, y, g;
	int pf, pe, cf, ce, nf, ne, source, sink;	// prev, cur, next

	while (n = in()) {
		memset(hi, 0, sizeof(hi)), memset(lim, 0, sizeof (lim));	// for MCF

		pf = pe = source = 0, tm[pf] = -1;
		for (i = 1; i < n; i++) {
			m = in();
			cf = pe+1, ce = cf+m-1, nf = ce+1, ne = nf-1;
			for (j = 0; j < m; j++) {
				tm[cf+j] = x = in(),
				y = in();
				for (k = nf; ; k++) {
					if (k > ne) { k = ++ne, tm[k] = y; break; } 
					if (y == tm[k]) break;
				}
				add_edge(cf+j, k, 1, in());
			}
			for (j = pf; j <= pe; j++) for (k = cf; k <= ce; k++) {
				if (tm[j] <= tm[k]) add_edge(j, k, 1, 0);
			}
			pf = nf, pe = ne;
		}
		sink = pe+1, V = sink+1;
		for (j = pf; j <= pe; j++) add_edge(j, sink, 1, 0);

		g = in();
		y = minCostFlow(&x, source, sink, g);
		printf("%d %d\n", g-x, y);

		for (i = 0; i < V; i++) if (lim[i]) free(edge[i]);
	}
	return 0;
}