#include <bits/stdc++.h>

using namespace std;

#define     mp              make_pair
#define     fs              first
#define     sc              second
#define     pob             pop_back
#define     pub             push_back
#define     eps             1E-7
#define     sz(a)           a.size()
#define     count_one       __builtin_popcount;
#define     count_onell     __builtin_popcountll;
#define     fastIO          ios_base::sync_with_stdio(false)
#define     PI              (acos(-1.0))
#define     linf            (1LL<<62)//>4e18
#define     inf             (0x7f7f7f7f)//>2e9

#define MAXN 710

#ifndef ONLINE_JUDGE
ifstream f("cmcm.in");
ofstream g("cmcm.out");
#endif

int n, m, e, s, d;
vector<int> vec[MAXN], cost[MAXN];
queue<int> Q;
int fn[MAXN], dist[MAXN], viz[MAXN];
int cap[MAXN][MAXN], flow[MAXN][MAXN], edge[MAXN][MAXN];

int bford() {
    for(int i = s; i <= d; ++i) {
        fn[i] = -1;
        dist[i] = inf;
        viz[i] = 0;
    }
    dist[s] = 0;
    viz[s] = true;

    for(Q.push(s); !Q.empty(); Q.pop()) {
        int nod = Q.front();
        viz[nod] = false;

        int len = vec[nod].size();
        for(int i = 0; i < len; ++i) {
            if(cap[nod][vec[nod][i]] > flow[nod][vec[nod][i]] && dist[vec[nod][i]] > dist[nod] + cost[nod][i]) {
                dist[vec[nod][i]] = dist[nod] + cost[nod][i];
                fn[vec[nod][i]] = nod;
                if(!viz[vec[nod][i]])
                    viz[vec[nod][i]] = true, Q.push(vec[nod][i]);
            }
        }
    }

    if(dist[d] < inf) {
        int minflow = inf;
        for(int nod = d; nod != s; nod = fn[nod]) {
            minflow = min(minflow, cap[fn[nod]][nod] - flow[fn[nod]][nod]);
        }

        for(int nod = d; nod != s; nod = fn[nod]) {
            flow[fn[nod]][nod] += minflow;
            flow[nod][fn[nod]] -= minflow;
        }

        return minflow * dist[d];
    }

    return 0;
}

int main() {
    f >> n >> m >> e;
    s = 1; d = n + m + 2;

    int a, b, c;
    for(int i = 1; i <= e; ++i) {
        f >> a >> b >> c;
        a++; b += n + 1;

        vec[a].pub(b); cost[a].pub(c);
        vec[b].pub(a); cost[b].pub(-c);

        cap[a][b] = 1;
        edge[a][b] = i;
    }

    for(int i = 2; i <= n + 1; ++i) {
        vec[s].pub(i); cost[s].pub(0);
        vec[i].pub(s); cost[i].pub(0);

        cap[s][i] = 1;
    }

    for(int i = n + 2; i <= n + m + 1; ++i) {
        vec[i].pub(d); cost[i].pub(0);
        vec[d].pub(i); cost[d].pub(0);

        cap[i][d] = 1;
    }

    int sol = 0;
    int improve = 1;
    while(improve)
        improve = bford(),
        sol += improve;

    int edges = 0;
    for(int i = 2; i <= n + 1; ++i)
        for(int j = n + 2; j <= n + m + 1; ++j)
            if(cap[i][j] && flow[i][j])
                edges++;
    g << edges << " " << sol << "\n";

    for(int i = 2; i <= n + 1; ++i)
        for(int j = n + 2; j <= n + m + 1; ++j)
            if(cap[i][j] && flow[i][j])
                g << edge[i][j] << " ";

    return 0;
}