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)

#include <iostream>
#include <vector>
#include <algorithm>
#include <queue>

using namespace std;

struct Tag {
    int depart, arrive, cost;
};

// テ・ツ、ツ堙ゥツ?催ィツセツコテ」ツ?古」ツ?づ」ツ?」テ」ツ?ヲテ」ツつづ・ツ仰陛」ツ??Primal-Dual
// POJ 2047 Concert Hall Scheduling
template <class Flow, class Cost>
struct edge/*{{{*/
{
  int index;
  Flow capacity, flow;
  Cost cost;
  int back;
  edge(int i, Flow c, Cost d, int b) : index(i), capacity(c), flow(0), cost(d), back(b) {}
};/*}}}*/


template <class Flow, class Cost>
void make_edge(vector<vector<edge<Flow, Cost> > > &g, int src, int dst, Flow c, Cost d)/*{{{*/
{
  const int i = g[src].size(), j = g[dst].size();
  g[src].push_back(edge<Flow, Cost>(dst, c, d, j));
  g[dst].push_back(edge<Flow, Cost>(src, 0, -d, i));
}/*}}}*/

const int MAXN = 100*40+10;

// O(V^2 U C) where
//  U = sum of capacity
//  C = sum of cost
template <class Flow, class Cost>
pair<Flow, Cost>
primal_dual(vector<vector<edge<Flow, Cost> > > &g, int N, int source, int sink, int max_flow)/*{{{*/
{
  pair<Flow, Cost> total;
  static Cost h[MAXN], dist[MAXN];
  static pair<int,int> parent[MAXN];
  for (Flow f = max_flow; f > 0; ) {
    fill_n(dist, N, 1000000);
    dist[source] = 0;
    fill_n(parent, N, make_pair(-1, -1));
    priority_queue<pair<Cost,int> > q;
    q.push(make_pair(0, source));
    while (!q.empty()) {
      const int n = q.top().second;
      const Cost c = -q.top().first;
      q.pop();
      if (dist[n] < c) {
        continue;
      }
      for (typename vector<edge<Flow, Cost> >::const_iterator it = g[n].begin(); it != g[n].end(); ++it) {
        if (it->capacity - it->flow > 0) {
          const Cost c2 = c + it->cost + h[n] - h[it->index];
          if (c2 < dist[it->index]) {
            dist[it->index] = c2;
            parent[it->index] = make_pair(n, it - g[n].begin());
            q.push(make_pair(-c2, it->index));
          }
        }
      }
    }
    if (parent[sink].first == -1) {
      break;
    }

    Flow e = f;
    for (int i = sink; i != source; i = parent[i].first) {
      const edge<Flow, Cost>& x = g[parent[i].first][parent[i].second];
      e = min(e, x.capacity - x.flow);
    }
    for (int i = sink; i != source; i = parent[i].first) {
      edge<Flow, Cost>& x = g[parent[i].first][parent[i].second];
      total.second += e * x.cost;
      x.flow += e;
      g[x.index][x.back].flow -= e;
    }
    f -= e;
    total.first += e;
    for (int i = 0; i < N; i++) {
      h[i] += dist[i];
    }
  }

  return total;
}/*}}}*/

int main() {
    cin.tie(0);
    ios::sync_with_stdio(0);
    while(true) {
        int N;
        cin >> N;
        if(!N) break;

        vector<vector<int> > arrive_times(N), depart_times(N);
        vector<vector<Tag> > trains(N-1);
        for(int i = 0; i < N-1; ++i) {
            int M;
            cin >> M;
            for(int j = 0; j < M; ++j) {
                Tag t;
                cin >> t.depart >> t.arrive >> t.cost;
                trains[i].push_back(t);
                arrive_times[i+1].push_back(t.arrive);
                depart_times[i].push_back(t.depart);
            }
        }
        int G;
        cin >> G;

        // Make graph
        // graph[n*40..n*40+19] = arrival node of station n
        // graph[n*40+20..n*40+39] = departural node of station n
        // graph[N*40] = Source
        // graph[N*40+1] = Sink
        vector<vector<edge<int,int> > > graph(N*40+2);
        for(int i = 0; i < N-1; ++i) {
            const vector<Tag> &v = trains[i];
            vector<int> &dv = depart_times[i];
            vector<int> &av = arrive_times[i+1];
            sort(dv.begin(), dv.end());
            sort(av.begin(), av.end());
            // テゥツァツ?テ」ツ?凝」ツつ嘉ゥツァツ?+1テ」ツ?クテ」ツ?ョテァツァツサテ・ツ仰?
            for(vector<Tag>::const_iterator it = v.begin(); it != v.end(); ++it) {
                int dep_node = i*40+20 + (find(dv.begin(), dv.end(), it->depart) - dv.begin());
                int arrive_node = (i+1)*40 + (find(av.begin(), av.end(), it->arrive) - av.begin());
                make_edge(graph, dep_node, arrive_node, 1, it->cost);
            }
            if(i > 0) {
                // テゥツァツ?テ・ツ按ーテァツ敖?」ツ?凝」ツつ嘉ゥツァツ?テ・ツ?コテァツ卍コテ」ツ?ョテァツァツサテ・ツ仰?
                const vector<int> &iav = arrive_times[i];
                for(int j = 0; j < (int)iav.size(); ++j) {
                    int arrive_node = i*40 + j;
                    int dep_node = i*40+20 + (lower_bound(dv.begin(), dv.end(), iav[j]) - dv.begin());
                    make_edge(graph, arrive_node, dep_node, 1, 0);
                }
            }
        }
        // Source
        // テゥツァツ?テ・ツ?コテァツ卍コテ」ツ?ョテ・ツ青?」ツδ偲」ツδシテ」ツδ嘉」ツ?ォテ・ツシツオテ」ツつ凝ッツシツ?
        {
            const vector<int> &dv = depart_times[0];
            const int SOURCE = N*40;
            for(int i = 0; i < (int)dv.size(); ++i) {
                int dep_node = 0*40+20 + i;
                make_edge(graph, SOURCE, dep_node, G, 0);
            }
        }
        // Sink
        // テゥツァツ?N-1)テ・ツ按ーテァツ敖?」ツ?ョテ・ツ青?」ツδ偲」ツδシテ」ツδ嘉」ツ?ォテ・ツシツオテ」ツつ凝ッツシツ?
        {
            const vector<int> &av = arrive_times[N-1];
            const int SINK = N*40+1;
            for(int i = 0; i < (int)av.size(); ++i) {
                int arrive_node = (N-1)*40 + i;
                make_edge(graph, arrive_node, SINK, 1, 0);
            }
        }
        pair<int,int> res = primal_dual(graph, N*40+2, N*40, N*40+1, G);
        cout << res.first << ' ' << res.second << endl;
    }
    return 0;
}