#include <stdio.h>
#include <vector>
#include <queue>

#define magic_sauce inline __attribute__((always_inline))

magic_sauce int min( int a, int b ){ return a < b ? a : b; }

const int MAXN = 602;
const int INF = 1e9;
const int NIL = -1;
const int MAXE = 50000;

int cap[MAXN][MAXN];
int cost[MAXN][MAXN];

std::vector<int> adj[MAXN];

int dist[MAXN];
int real_dist[MAXN];
int prev_dist[MAXN];

int par[MAXN];

void init_potentials( int n, int src ){
  int u;

  for( u = 0 ; u < n ; u++ )
    dist[u] = +INF;

  std::queue<int> q;

  dist[src] = 0;
  q.push( src );

  while( !q.empty() ){
    u = q.front();
    q.pop();

    for( int v : adj[u] )
      if( cap[u][v] && dist[u] + cost[u][v] < dist[v] ){
        dist[v] = dist[u] + cost[u][v];
        q.push( v );
      }
  }

  for( u = 0 ; u < n ; u++ )
    prev_dist[u] = dist[u];
}

bool dijkstra( int n, int src, int dest ){
  int u, aux;
  std::pair<int, int> top;

  for( u = 0 ; u < n ; u++ )
    dist[u] = +INF;

  std::priority_queue<std::pair<int, int>> pq;

  pq.push( std::make_pair( 0, src ) );
  dist[src] = 0;
  par[src] = NIL;
  while( !pq.empty() ){
    top = pq.top();
    pq.pop();

    if( top.first == -dist[top.second] ){
      u = top.second;

      for( int v : adj[u] ){
        aux = cost[u][v] + prev_dist[u] - prev_dist[v];

        if( cap[u][v] && dist[u] + aux < dist[v] ){
          dist[v] = dist[u] + aux;
          par[v] = u;
          pq.push( std::make_pair( -dist[v], v ) );
        }
      }
    }
  }

  for( u = 0 ; u < n ; u++ )
    real_dist[u] = dist[u] + prev_dist[u] - prev_dist[src];

  for( u = 0 ; u < n ; u++ )
    prev_dist[u] = real_dist[u];

  return dist[dest] < +INF;
}

struct Edge {
  int u, v;
} edges[MAXE];

int main(){
  FILE *fin = fopen( "cmcm.in", "r" );
  FILE *fout = fopen( "cmcm.out", "w" );

  int n, m, e, i, a, b;
  int nodes, src, dest;
  int flow, flow_cost, augment_flow, augment_cost;

  fscanf( fin, "%d%d%d", &n, &m, &e );
  src = n + m;
  dest = n + m + 1;
  nodes = n + m + 2;
  
  for( i = 0 ; i < n ; i++ ){
    adj[src].push_back( i );
    cost[src][i] = cost[i][src] = 0;
    cap[src][i] = 1;
  }

  for( i = n ; i < n + m ; i++ ){
    adj[i].push_back( dest );
    cost[dest][i] = cost[i][dest] = 0;
    cap[i][dest] = 1;
  }

  for( i = 0 ; i < e ; i++ ){
    fscanf( fin, "%d%d", &a, &b );
    a--;
    b--;

    b += n;

    edges[i] = Edge{ a, b }; // needed to output matching
    adj[a].push_back( b );
    adj[b].push_back( a );

    cap[a][b] = 1;
    fscanf( fin, "%d", &cost[a][b] );
    cost[b][a] = -cost[a][b];
  }

  flow = flow_cost = 0;
  init_potentials( nodes, src );
  while( dijkstra( nodes, src, dest ) ){
    augment_cost = 0;
    augment_flow = +INF;
    for( a = dest ; par[a] != NIL ; a = par[a] ){
      augment_cost += cost[par[a]][a];
      augment_flow = min( augment_flow, cap[par[a]][a] );
    }

    flow += augment_flow;
    flow_cost += augment_flow * augment_cost;
    for( a = dest ; par[a] != NIL ; a = par[a] ){
      cap[par[a]][a] -= augment_flow;
      cap[a][par[a]] += augment_flow;
    }
  }

  fprintf( fout, "%d %d\n", flow, flow_cost );
  for( i = 0 ; i < e ; i++ )
    if( !cap[edges[i].u][edges[i].v] )
      fprintf( fout, "%d ", i + 1 );

  fputc( '\n', fout );

  fclose( fin );
  fclose( fout );
  return 0;
}