#include <bits/stdc++.h>

using namespace std;

const int MAXN = 605;

#define nod first
#define dist second

class cmp{
    public:
    bool operator ()(pair<int, int> &a, pair<int, int> &b){
        return a.dist > b.dist;
    }
};

int flux[MAXN][MAXN], cost[MAXN][MAXN], sursa[MAXN], distBellmanFord[MAXN], distDijkstra[MAXN], distUpdate[MAXN], muchie[MAXN][MAXN];
vector<int> graf[MAXN], ans;
queue<int> coada;
priority_queue<pair<int, int>, vector<pair<int, int>>, cmp> pq;

int n, m, s, d, l, r;

void BellmanFord(){
    for(int i = 1; i <= d; ++i) distBellmanFord[i] = 1e9;
    distBellmanFord[s] = 0;
    coada.push(s);
    while(!coada.empty()){
        int x = coada.front();
        coada.pop();
        for(auto y: graf[x]){
            if(distBellmanFord[y] > distBellmanFord[x] + cost[x][y] && flux[x][y] > 0){
                distBellmanFord[y] = distBellmanFord[x] + cost[x][y];
                coada.push(y);
            }
        }
    }
}

bool Dijkstra(){
    for(int i = 1; i <= d; ++i) distDijkstra[i] = distUpdate[i] = 1e9;
    distDijkstra[s] = distUpdate[s] = 0;
    memset(sursa, 0, d + 1);
    bool ans = 0;
    pq.push({s, distDijkstra[s]});
    while(!pq.empty()){
        int x = pq.top().nod, xdist = pq.top().dist;
        pq.pop();
        if(xdist != distDijkstra[x]) continue;
        if(x == d) ans = 1;
        for(auto y: graf[x]){
            if(flux[x][y] > 0 && distDijkstra[y] > distDijkstra[x] + cost[x][y] + distBellmanFord[x] - distBellmanFord[y]){
                distDijkstra[y] = distDijkstra[x] + cost[x][y] + distBellmanFord[x] - distBellmanFord[y];
                distUpdate[y] = distUpdate[x] + cost[x][y];
                sursa[y] = x;
                pq.push({y, distDijkstra[y]});
            }
        }
    }
    for(int i = 1; i <= d; ++i) distBellmanFord[i] = distUpdate[i];
    return ans;
}

int main()
{
    ifstream fin("cmcm.in");
    ofstream fout("cmcm.out");
    fin >> l >> r >> m;
    n = l + r; s = n + 1; d = n + 2;
    for(int i = 1; i <= m; ++i){
        int x, y;
        fin >> x >> y;
        y += l;
        fin >> cost[x][y];
        cost[y][x] = -cost[x][y];
        flux[x][y] = 1;
        graf[x].push_back(y); graf[y].push_back(x);
        muchie[x][y] = i;
    }
    for(int i = 1; i <= l; ++i){
        flux[s][i] = 1;
        graf[s].push_back(i); graf[i].push_back(s);
    }
    for(int i = l + 1; i <= n; ++i){
        flux[i][d] = 1;
        graf[i].push_back(d); graf[d].push_back(i);
    }
    BellmanFord();
    int mxcup = 0, mncost = 0;
    while(Dijkstra()){
        int mnflux = 1e9;
        for(int i = d; i != s; i = sursa[i]) mnflux = min(mnflux, flux[sursa[i]][i]);
        if(mnflux == 0) continue;
        for(int i = d; i != s; i = sursa[i]){
            flux[sursa[i]][i] -= mnflux;
            flux[i][sursa[i]] += mnflux;
        }
        mncost += mnflux * distUpdate[d];
        mxcup++;
    }
    fout << mxcup << " " << mncost << "\n";
    for(int i = 1; i <= l; ++i){
        for(int j = l + 1; j <= n; ++j)
            if(flux[j][i] == 1) fout << muchie[i][j] << " ";
    }
    return 0;
}