#include <iostream>
#include <fstream>
#include <vector>
#include <queue>

using namespace std;

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

vector<int> gf[705];
int cap[705][705], cost[705][705], muchie[705][705], flux[705][705];
priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;
int n, m, e, s, d, tata[705], dist[705], fluxmax;
bool viz[705];
const int inf = 2e9;

bool bellman_ford() {
    for (int i = 1; i <= d; i++)
        dist[i] = inf, viz[i] = 0;
    dist[s] = 0;
    viz[s] = 1;
    queue<int> q;
    q.push(s);
    while (!q.empty()) {
        int nod = q.front();
        q.pop();
        viz[nod] = 0;
        for (int vecin : gf[nod])
            if (cap[nod][vecin] > flux[nod][vecin] && dist[vecin] > dist[nod] + cost[nod][vecin]) {
                dist[vecin] = dist[nod] + cost[nod][vecin];
                tata[vecin] = nod;
                if (!viz[vecin]) {
                    viz[vecin] = 1;
                    q.push(vecin);
                }
            }
    }
    if (dist[d] == inf)
        return false; // nu am gasit un drum mai bun
    else {
        int fluxnou = inf;
        for (int i = d; i != s; i = tata[i])
            fluxnou = min(fluxnou, cap[tata[i]][i] - flux[tata[i]][i]); // aflam fluxul minim ce poate fi adaugat
        for (int i = d; i != s; i = tata[i]) {
            flux[tata[i]][i] += fluxnou; // flux[] functioneaza invers fata de capacitate (deoarece scadem din capacitate)
            flux[i][tata[i]] -= fluxnou;
        }
        fluxmax += fluxnou * dist[d]; // adaugam acest flux la raspuns
        return true;
    }
}

void construieste_flux() {
    for (int i = 2; i <= n + 1; i++) {
        gf[1].push_back(i);
        gf[i].push_back(1);
        cap[1][i] = 1;
        // cost[1][i] = 0;
        // cost[i][1] = 0;
    }
    for (int i = n + 2; i <= n + m + 1; i++) {
        gf[i].push_back(d);
        gf[d].push_back(i);
        cap[i][d] = 1;
        // cost[i][d] = 0;
        // cost[d][i] = 0;
    }
}

int main()
{
    fin >> n >> m >> e;
    s = 1;
    d = n + m + 2;
    for (int i = 1; i <= e; i++) {
        int x, y, c;
        fin >> x >> y >> c;
        x++, y += n + 1;
        gf[x].push_back(y);
        gf[y].push_back(x);
        cap[x][y] = 1;
        muchie[x][y] = i;
        cost[x][y] = c;
        cost[y][x] = -c;
    }
    construieste_flux();
    int tmp = 1;
    while (bellman_ford());
    queue<int> q;
    for (int i = 2; i <= n + 1; i++)
        for (int j = n + 2; j <= n + m + 1; j++)
            if (cap[i][j] && flux[i][j]) {
                q.push(muchie[i][j]);
                break; // urmatorul nod
            }
    fout << q.size() << " " << fluxmax << "\n";
    while (!q.empty()) {
        fout << q.front() << " ";
        q.pop();
    }
    return 0;
}