#include <cstdio>
#include <vector>
#include <climits>
#include <queue>
#include <fstream>

#define Nmax 602

using namespace std;

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

vector<int> graph[Nmax];

int dad[Nmax], flow[Nmax][Nmax], capacity[Nmax][Nmax], cost[Nmax][Nmax], dist[Nmax], idx[Nmax][Nmax];
int maxFlow, minCost, edges, n, m, source, sink;
bool inq[Nmax];
queue<int> q;

bool bellmanford() {
    int node, i, minFlow, son;

    for(i = 0; i <= n + m + 1; ++i)
        dist[i] = INT_MAX;

    dist[source] = 0;
    q.push(source);
    inq[source] = true;

    while(!q.empty()) {
        node = q.front();
        q.pop();
        inq[node] = false;

        if(node == sink) continue;

        for(i = 0; i < graph[node].size(); ++i) {
            son = graph[node][i];
            if(flow[node][son] < capacity[node][son] && dist[node] + cost[node][son] < dist[son]) {
                dist[son] = dist[node] + cost[node][son];
                dad[son] = node;
                if(!inq[son]) {
                    inq[son] = true;
                    q.push(son);
                }
            }
        }
    }

    if(dist[sink] == INT_MAX) return false;

    minFlow = INT_MAX;
    for(node = sink; node != source; node = dad[node])
        minFlow = min(minFlow, capacity[dad[node]][node] - flow[dad[node]][node]);

    for(node = sink; node != source; node = dad[node]) {
        flow[dad[node]][node] += minFlow;
        flow[node][dad[node]] -= minFlow;
    }

    maxFlow += minFlow;
    minCost += minFlow * dist[sink];

    return true;
}


int main() {
    int x, y, c;
    fin >> n >> m >> edges;

    for(int i = 1; i <= edges; i++) {
        fin >> x >> y >> c;
        y += n;

        capacity[x][y] = 1;
        cost[x][y] = c;
        cost[y][x] = -c;
        idx[x][y] = i;

        graph[x].push_back(y);
        graph[y].push_back(x);
    }

    for(int i = 1; i <= n; i++) {
        graph[0].push_back(i);
        capacity[0][i] = 1;
        cost[0][i] = 0;
    }

    for(int i = n + 1; i <= n + m; i++) {
        graph[i].push_back(n + m + 1);
        capacity[i][n + m + 1] = 1;
    }

    source = 0;
    sink = n + m + 1;

    while(bellmanford());

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

    for(int i = 1; i <= n; i++)
        for(int j = n + 1; j <= n + m; ++j)
            if(flow[i][j] > 0)
                fout << idx[i][j] << " ";
}