#include <iostream>
#include <fstream>
#include <algorithm>
#include <vector>
#include <memory.h>
#include <queue>

#define newn G[nod][i]

using namespace std;

ifstream fin("cmcm.in");
ofstream fout("cmcm.out");

const int NMAX = 310 * 2;
const int oo = 0x3f3f3f3f;

int S, D, N, M, E, MC[NMAX][NMAX], F[NMAX][NMAX],
C[NMAX][NMAX], CST[NMAX][NMAX], DIST[NMAX], T[NMAX];
vector <int> G[NMAX];
vector <bool> inq(NMAX);
queue <int> Q;

int sol, cmin;

void Add(int x, int y)
{
    G[x].push_back(y);
    G[y].push_back(x);
}

bool Bellman_Ford()
{
    memset(DIST, oo, sizeof DIST);
    DIST[S] = 0; Q.push(S); inq[S] = 1;
    while(!Q.empty())
    {
        int nod = Q.front(); Q.pop(); inq[nod] = 0;
        for(unsigned i = 0; i < G[nod].size(); i++)
            if(F[nod][newn] < C[nod][newn])
                if(DIST[nod] + CST[nod][newn] < DIST[newn])
                {
                    T[newn] = nod;
                    DIST[newn] = DIST[nod] + CST[nod][newn];
                    if(!inq[newn]) inq[newn] = 1, Q.push(newn);
                }
    }
    return DIST[D] != oo;
}

void Update_Flux()
{
    for(int j = D; j != S; j = T[j])
        F[T[j]][j]++, F[j][T[j]]--;
    sol++;
    cmin += DIST[D];
}

int main()
{
    fin >> N >> M >> E;
    D = N + M + 1;
    for(int i = 1; i <= E; i++)
    {
        int x, y, c;
        fin >> x >> y >> c; y += N;
        Add(S, x); Add(x, y); Add(y, D);
        C[S][x] = C[x][y] = C[y][D] = 1;
        CST[x][y] = c; CST[y][x] = -c;
        MC[x][y] = i;
    }

    while(Bellman_Ford())
        Update_Flux();
    fout << sol << ' ' << cmin << '\n';
    for(int i = 1; i <= N; i++)
        for(int j = N + 1; j <= N + M; j++)
            if(F[i][j] > 0)
                fout << MC[i][j] << ' ';
    return 0;
}