#include <bits/stdc++.h>
#define NMAX  602
#define INF 999999999

using namespace std;

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

int sizeL, sizeR, M;
int S, D;
vector <int> g[NMAX + 5];
int mch[NMAX + 5][NMAX + 5];
int capacity[NMAX + 5][NMAX + 5], flow[NMAX + 5][NMAX + 5];
int cost[NMAX + 5][NMAX + 5];
int costTo[NMAX + 5], pumpFlow[NMAX + 5];
int bef[NMAX + 5];
bool seen[NMAX + 5];


bool BellmanFord() {

    for(int i = S; i <= D; i++)
        costTo[i] = INF, pumpFlow[i] = INF;

    queue <int> Q;
    Q.push(S);
    costTo[S] = 0;
    seen[S] = 1;

    while(!Q.empty()) {
        int node = Q.front();
        Q.pop();
        seen[node] = 0;
        for(auto it : g[node])
            if(flow[node][it] < capacity[node][it])
                if(costTo[it] > costTo[node] + cost[node][it]) {
                    costTo[it] = costTo[node] + cost[node][it];
                    bef[it] = node;
                    pumpFlow[it] = min(pumpFlow[node], capacity[node][it] - flow[node][it]);
                    if(!seen[it]) {
                        seen[it] = 1;
                        Q.push(it);
                    }
                }
    }

    return costTo[D] != INF;
}

int main() {

    fin >> sizeL >> sizeR >> M;
    for(int i = 1; i <= M; i++) {
        int x, y, cst;
        fin >> x >> y >> cst;
        mch[x][y + sizeL] = i;
        mch[y + sizeL][x] = i;
        g[x].push_back(y + sizeL);
        g[y + sizeL].push_back(x);
        capacity[x][y + sizeL] = 1;
        cost[x][y + sizeL] = cst;
        cost[y + sizeL][x] = -cst;
    }

    S = 0, D = sizeL + sizeR + 1;
    for(int i = 1; i <= sizeL; i++) {
        g[S].push_back(i);
        g[i].push_back(S);
        capacity[S][i] = 1;
    }
    for(int i = 1; i <= sizeR; i++) {
        g[i + sizeL].push_back(D);
        g[D].push_back(i + sizeL);
        capacity[i + sizeL][D] = 1;
    }

    int maxFlow = 0, minCost = 0;

    while(BellmanFord()) {
        for(int i = D; i != S; i = bef[i]) {
            flow[bef[i]][i] += pumpFlow[D];
            flow[i][bef[i]] -= pumpFlow[D];
        }

        maxFlow += pumpFlow[D];
        minCost += pumpFlow[D] * costTo[D];
    }

    fout << maxFlow << ' ' << minCost << '\n';

    for(int i = 1; i <= sizeL; i++)
        for(int j = 1; j <= sizeR; j++)
            if(flow[i][j + sizeL] == 1)
                fout << mch[i][j + sizeL] << ' ';

    return 0;

}