#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, l, r;

void BellmanFord(){
    for(int i = 0; i <= n + 1; ++i) distBellmanFord[i] = 1e9;
    distBellmanFord[0] = 0;
    coada.push(0);
    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 = 0; i <= n + 1; ++i) distUpdate[i] = 1e9;
    distDijkstra[0] = distUpdate[0] = 0;
    bool ans = 0;
    pq.push({0, distDijkstra[0]});
    while(!pq.empty()){
        int x = pq.top().nod, xdist = pq.top().dist;
        pq.pop();
        if(x == n + 1) ans = 1;
        if(xdist != distDijkstra[x]) continue;
        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 <= n; ++i) distBellmanFord[i] = distUpdate[i];
    return ans;
}

int main()
{
    ifstream fin("cmcm.in");
    ofstream fout("cmcm.out");
    fin >> l >> r >> m;
    n = l + r;
    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[0][x] = 1;
        flux[x][y] = 1;
        flux[y][n + 1] = 1;
        graf[0].push_back(x);
        graf[x].push_back(y);
        graf[x].push_back(0);
        graf[y].push_back(x);
        graf[y].push_back(n + 1);
        graf[n + 1].push_back(y);
        muchie[x][y] = i;
    }
    BellmanFord();
    for(int i = 0; i <= n + 1; ++i) distDijkstra[i] = 1e9;
    int mncost = 0;
    while(Dijkstra()){
        int mnflux = 1e9, crt = n + 1;
        while(crt != 0){
            mnflux = min(mnflux, flux[sursa[crt]][crt]);
            crt = sursa[crt];
        }
        if(mnflux == 0) continue;
        crt = n + 1;
        while(crt != 0){
            flux[sursa[crt]][crt] -= mnflux;
            flux[crt][sursa[crt]] += mnflux;
            crt = sursa[crt];
            if(muchie[sursa[crt]][crt] > 0) ans.push_back(muchie[sursa[crt]][crt]);
        }
        mncost += mnflux * distUpdate[n + 1];
        memset(sursa, 0, n + 2);
        for(int i = 0; i <= n + 1; ++i) distDijkstra[i] = 1e9;
    }
    fout << ans.size() << " " << mncost << "\n";
    for(auto x: ans) fout << x << " ";
    return 0;
}