#include <bits/stdc++.h>
#define NMAX 710
#define EMAX 50000 + 1
#define shift 301
using namespace std;
ifstream fin("cmcm.in");
ofstream fout("cmcm.out");

int n, m, e;
int capacitate[NMAX][NMAX], flux[NMAX][NMAX], cost[NMAX][NMAX], muchie[NMAX][NMAX];
vector<int> parent = vector<int>(NMAX);

vector<vector<int>> graph = vector<vector<int>>(NMAX, vector<int>());

 int s = 0, d = 709;

void cupleaza(){

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

    for(int i=1 + shift; i<=m+shift; i++){
        graph.at(i).push_back(d);
        cost[i][d] = cost[i][d] = 0;
        capacitate[i][d] = 1;

    }
}


bool dijkstra(){
    queue<int> q;
    vector<int> dist = vector<int>(NMAX, INT_MAX);
    vector<bool> inQueue = vector<bool>(NMAX);
    dist.at(s) = 0;
    q.push(s);

    while(!q.empty()){

        int node = q.front();
        q.pop();
        inQueue[node] = false;

        for(auto& kid:graph[node]){
            if(capacitate[node][kid]==flux[node][kid]) continue;

            int dn = dist.at(node) + cost[node][kid];

            if(dist.at(kid)>dn){
                dist.at(kid) = dn;
                parent[kid] = node;

                if(inQueue.at(kid)==false){
                    inQueue.at(kid) = true;
                    q.push(kid);
                }
            }
        }
    }
    if(dist.at(d)==INT_MAX) return false;

    return true;
}

int main()
{
    fin>>n>>m>>e;

    int l, r, c;
    for(int i=1; i<=e; i++){
        fin>>l>>r>>c;
        r = r + shift;
        graph.at(l).push_back(r);
        graph.at(r).push_back(l);
        capacitate[l][r] = 1;

        cost[l][r] = c;
        cost[r][l] = -c;

        muchie[l][r] = i;
    }

    cupleaza();
    int mincost = 0;
    while(dijkstra()){
        int mflux = INT_MAX;

        for(int i=d; i!=s; i=parent[i])
            mflux = min(mflux, capacitate[parent[i]][i] - flux[parent[i]][i]);

        for(int i=d; i!=s; i=parent[i])
        {

            flux[parent[i]][i] +=mflux;
            flux[i][parent[i]] -=mflux;

            mincost += cost[parent[i]][i];
        }

    }
    int nr=0;
    for(int i=1; i<=n; i++){
        for(int j=1+shift; j<=m+shift; j++)
        if(capacitate[i][j]&&flux[i][j]){
            nr++;   break;
        }
    }

    fout<<nr<<" "<<mincost<<endl;

    for(int i=1; i<=n; i++){
        for(int j=1+shift; j<=m+shift; j++)
        if(capacitate[i][j]&&flux[i][j]){
            fout<<muchie[i][j]<<" ";   break;
        }
    }



}