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

using namespace std;

#define pii pair <int, int>

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

const int NMAX = 600;
const int INF = 1e9;

const int EMAX = 5e4;

int nr;
vector <pii> adj[NMAX + 1];
int flow[NMAX + 1][NMAX + 1];

int aux[NMAX + 1];
bool inQ[NMAX + 1];

void BF(int source){
    for(int i = 0; i <= nr; i++){
        aux[i] = INF;
    }
    
    queue <int> Q;
    Q.push(source);
    inQ[source] = true;
    aux[source] = 0;

    while(!Q.empty()){
        int node = Q.front();

        Q.pop();
        inQ[node] = false;

        for(pii vec : adj[node]){
            if(flow[node][vec.first] > 0 && aux[node] + vec.second < aux[vec.first]){
                aux[vec.first] = aux[node] + vec.second;
                if(!inQ[vec.first]){
                    Q.push(vec.first);
                }
            }
        }
    }
}   

priority_queue <pii, vector <pii>, greater <pii>> pq;

int dist[NMAX + 1];
int real[NMAX + 1];

int parent[NMAX + 1];

bool DJK(int source, int destination){
    for(int i = 0; i <= nr; i++){
        dist[i] = real[i] = INF;
    }

    while(!pq.empty()){
        pq.pop();
    }

    dist[source] = real[source] = 0;
    pq.push({dist[source], source});

    while(!pq.empty()){
        int node = pq.top().second;
        int val = pq.top().first;
        pq.pop();

        if(val == dist[node]){
            for(pii vec : adj[node]){
                if(flow[node][vec.first] > 0 && dist[node] + vec.second + aux[node] - aux[vec.first] < dist[vec.first]){
                    dist[vec.first] = dist[node] + vec.second + aux[node] - aux[vec.first];
                    real[vec.first] = real[node] + vec.second;

                    parent[vec.first] = node;
                    pq.push({dist[vec.first], vec.first});
                }
            }
        }
    }

    return (dist[destination] != INF);
}

pii edges[EMAX + 1];

int main(){

    int n, m, e;
    fin >> n >> m >> e;

    for(int i = 1; i <= e; i++){
        int a, b, c;
        fin >> a >> b >> c;
        adj[a].push_back({b + n, c});
        adj[b + n].push_back({a, -c});
        flow[a][b + n] = 1;

        edges[i] = {a, b};
    }

    int s = 0, d = n + m + 1;
    for(int i = 1; i <= n; i++){
        adj[s].push_back({i, 0});
        adj[i].push_back({s, 0});
        flow[s][i] = 1;
    }

    for(int i = 1; i <= m; i++){
        adj[n + i].push_back({d, 0});
        adj[d].push_back({n + 1, 0});
        flow[n + i][d] = 1;
    }

    nr = n + m + 1;

    BF(s);

    int maxFlow = 0;
    int minCost = 0;

    while(DJK(s, d)){
        int node = d, mini = INF;

        while(node != s){
            mini = min(mini, flow[parent[node]][node]);
            node = parent[node];
        }

        node = d;
        while(node != s){
            flow[parent[node]][node] -= mini;
            flow[node][parent[node]] += mini;
            node = parent[node];
        }

        maxFlow += mini;
        minCost += mini * real[d];

        for(int i = 0; i <= nr; i++){
            aux[i] = dist[i];
        }
    }

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

    for(int i = 1; i <= e; i++){
        if(flow[edges[i].first][n + edges[i].second] == 0){
            fout << i << ' ';
        }
    }

    fout << '\n';

    return 0;
}