#include <bits/stdc++.h>

using namespace std;

const int NMAX = 610;
const int INF = 1e9;

int flux[NMAX + 1][NMAX + 1];
int cost[NMAX + 1][NMAX + 1];
vector <int> edges[NMAX + 1];

int viz[NMAX + 1];
int minDist[NMAX + 1];
int realDist[NMAX + 1];
int fakeDist[NMAX + 1];

int prv[NMAX + 1];
bool inQ[NMAX + 1];

int s, d, n;

void bellman() {
    for ( int i = s; i <= d; i ++ ) {
        minDist[i] = INF;
    }

    minDist[s] = 0;
    queue <int> q;
    q.push( s );
    while ( !q.empty() ) {
        int node = q.front();
        q.pop();
        inQ[node] = false;
        for ( auto vec : edges[node] ) {
            if ( flux[node][vec] > 0 && minDist[node] + cost[node][vec] < minDist[vec] ) {
                minDist[vec] = minDist[node] + cost[node][vec];
                if ( !inQ[vec] ) {
                    q.push( vec );
                    inQ[vec] = true;
                }
            }
        }
    }
}
bool dijkstra() {
    for ( int i = s; i <= d; i ++ ) {
        viz[i] = false;
        realDist[i] = minDist[i];
        fakeDist[i] = INF;
        prv[i] = 0;
    }
    minDist[s] = fakeDist[s] = 0;

    priority_queue <pair<int, int>> pq;

    pq.push( {0, s} );

    while ( !pq.empty() ) {
        int node = pq.top().second;
        pq.pop();
        if ( viz[node] ) continue;
        viz[node] = true;
        for ( auto vec : edges[node] ) {
            if ( flux[node][vec] && fakeDist[node] + realDist[node] + cost[node][vec] - realDist[vec] < fakeDist[vec] ) {
                fakeDist[vec] = fakeDist[node] + realDist[node] + cost[node][vec] - realDist[vec];
                minDist[vec] = minDist[node] + cost[node][vec];
                prv[vec] = node;
                pq.push( {-fakeDist[vec], vec} );
            }
        }
    }
    return prv[d] != 0;
}

map <pair<int, int>, int> indici;

int main() {
    ifstream fin( "cmcm.in" );
    ofstream fout( "cmcm.out" );
    int n, m, e;
    fin >> n >> m >> e;
    for ( int i = 1, a, b, c; i <= e; i ++ ) {
        fin >> a >> b >> c;
        b += n;
        indici[{a, b}] = i;
        edges[a].push_back( b );
        edges[b].push_back( a );
        flux[a][b] = 1;
        cost[a][b] = c;
        cost[b][a] = -c;
    }
    s = 0;
    d = n + m + 1;

    for ( int i = 1; i <= n; i ++ ) {
        edges[s].push_back( i );
        edges[i].push_back( s );
        flux[s][i] = 1;
    }
        for ( int i = n + 1; i <= n + m; i ++ ) {
        edges[d].push_back( i );
        edges[i].push_back( d );
        flux[i][d] = 1;
    }

    bellman();

    int maxFlow = 0;
    int minCost = 0;
    while( dijkstra() ) {
        cout << "NODE" << endl;
        int f = INF, node = d, c = 0;
        while ( node != s ) {
            f = min( f, flux[prv[node]][node] );
            c += cost[prv[node]][node];
            node = prv[node];
        }
        node = d;
        while ( node != s ) {
            flux[prv[node]][node] -= f;
            flux[node][prv[node]] += f;

            node = prv[node];
        }
        maxFlow += f;
        minCost += c * f;
    }
    fout << maxFlow << ' ' << minCost << '\n';
    for ( int i = 1; i <= n; i ++ ) {
        for ( auto vec : edges[i] ) {
            if ( n + 1 <= vec && vec <= n + m && flux[vec][i] ) {
                fout << indici[{i, vec}] << ' ';
            }
        }
    }
    return 0;
}