#include <cstdio>
#include <cstring>
#include <cassert>

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

using namespace std;

const int MaxN = 605;
const int oo = 0x3f3f3f3f;

vector<int> G[MaxN];
int N, M, Edge[MaxN][MaxN], Source, Sink;
int Capacity[MaxN][MaxN], Flow[MaxN][MaxN], MaxFlow, MinCost;
int Cost[MaxN][MaxN], Father[MaxN], Distance[MaxN];
bool InQ[MaxN];
queue<int> Q;

inline void InitBellmanFord(const int &Start) {
    memset(Father, -1, sizeof(Father));
    memset(Distance, oo, sizeof(Distance));
    memset(InQ, 0, sizeof(InQ));
    Distance[Start] = 0;
    Q.push(Start), InQ[Start] = true;
}

bool BellmanFord(const int &Start, const int &End) {
    for (InitBellmanFord(Start); !Q.empty(); Q.pop()) {
        int X = Q.front(); InQ[X] = false;
        for (vector<int>::iterator Y = G[X].begin(); Y != G[X].end(); ++Y) {
            if (Capacity[X][*Y] > Flow[X][*Y] && Distance[X] + Cost[X][*Y] < Distance[*Y]) {
                Distance[*Y] = Distance[X] + Cost[X][*Y], Father[*Y] = X;
                if (!InQ[*Y])
                    Q.push(*Y), InQ[*Y] = true;
            }
        }
    }
    return Father[End] != -1;
}

void MaximumFlow() {
    MaxFlow = MinCost = 0;
    while (BellmanFord(Source, Sink)) {
        int CurrentFlow = N;
        for (int X = Sink; X != Source; X = Father[X])
            CurrentFlow = min(CurrentFlow, Capacity[Father[X]][X] - Flow[Father[X]][X]);
        for (int X = Sink; X != Source; X = Father[X])
            Flow[Father[X]][X] += CurrentFlow, Flow[X][Father[X]] -= CurrentFlow;
        MaxFlow += CurrentFlow, MinCost += CurrentFlow * Distance[Sink];
    }
}

void Read() {
    assert(freopen("cmcm.in", "r", stdin));
    int E; assert(scanf("%d %d %d", &N, &M, &E) == 3);
    for (int i = 1; i <= E; ++i) {
        int X, Y, C; assert(scanf("%d %d %d", &X, &Y, &C) == 3);
        Y += N;
        G[X].push_back(Y), G[Y].push_back(X);
        Edge[X][Y] = i;
        Cost[X][Y] = C, Cost[Y][X] = -C;
        Capacity[X][Y] = 1, Capacity[Y][X] = 0;
    }
    Source = 0, Sink = N + M + 1;
    for (int X = 1; X <= N; ++X) {
        G[Source].push_back(X), G[X].push_back(Source);
        Cost[Source][X] = Cost[X][Source] = 0;
        Capacity[Source][X] = 1;
    }
    for (int X = N + 1; X <= N + M; ++X) {
        G[X].push_back(Sink), G[Sink].push_back(X);
        Cost[X][Sink] = Cost[Sink][X] = 0;
        Capacity[X][Sink] = 1, Capacity[Sink][X] = 0;
    }
}

void Print() {
    assert(freopen("cmcm.out", "w", stdout));
    printf("%d %d\n", MaxFlow, MinCost);
    for (int X = 1; X <= N; ++X)
        for (int Y = N + 1; Y <= N + M; ++Y)
            if (Flow[X][Y] > 0)
                printf("%d ", Edge[X][Y]);
    printf("\n");
}

int main() {
    Read();
    MaximumFlow();
    Print();
    return 0;
}