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

using namespace std;

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

const int max_size = 701, INF = 1e9 + 1;

#define pii pair <int, int>

int cap[max_size][max_size], cost[max_size][max_size], d[max_size], pr[max_size], t[max_size], aux[max_size], n, m;
vector <int> mc[max_size];
vector <pii> muchii;
queue <int> q;
priority_queue <pii, vector <pii>, greater <pii>> pq;

void bf ()
{
  for (int i = 1; i <= n + m + 2; i++)
  {
    aux[i] = INF;
  }
  aux[1] = 0;
  q.push(1);
  while (!q.empty())
  {
    int nod = q.front();
    q.pop();
    d[nod] = 0;
    for (auto f : mc[nod])
    {
      if (cap[nod][f] > 0 && aux[nod] + cost[nod][f] < aux[f])
      {
        aux[f] = aux[nod] + cost[nod][f];
        if (d[f] == 0)
        {
          d[f] = 1;
          q.push(f);
        }
      }
    }
  }
}

bool djk ()
{
  for (int i = 1; i <= n + m + 2; i++)
  {
    d[i] = INF;
    pr[i] = INF;
  }
  d[1] = 0;
  pr[1] = 0;
  pq.push({0, 1});
  while (!pq.empty())
  {
    int val = pq.top().first, nod = pq.top().second;
    pq.pop();
    if (val == d[nod])
    {
      for (auto f : mc[nod])
      {
        if (cap[nod][f] > 0 && d[nod] + cost[nod][f] + aux[nod] - aux[f] < d[f])
        {
          d[f] = d[nod] + cost[nod][f] + aux[nod] - aux[f];
          pr[f] = pr[nod] + cost[nod][f];
          t[f] = nod;
          pq.push({d[f], f});
        }
      }
    }
  }
  return (d[n + m + 2] != INF);
}

int main ()
{
  int q;
  in >> n >> m >> q;
  for (int i = 2; i <= n + 1; i++)
  {
    cap[1][i] = 1;
    mc[1].push_back(i);
    mc[i].push_back(1);
  }
  for (int i = 1; i <= m; i++)
  {
    cap[n + i + 1][n + m + 2] = 1;
    mc[n + i + 1].push_back(n + m + 2);
    mc[n + m + 2].push_back(n + i + 1);
  }
  while (q--)
  {
    int l, r, c;
    in >> l >> r >> c;
    cap[l + 1][r + n + 1] = INF;
    cost[l + 1][r + n + 1] = c;
    cost[r + n + 1][l + 1] = -c;
    mc[l + 1].push_back(r + n + 1);
    mc[r + n + 1].push_back(l + 1);
    muchii.push_back({l, r});
  }
  bf();
  int ans = 0, max_flow = 0;
  while (djk())
  {
    int nod = n + m + 2, flux = INF;
    while (nod != 1)
    {
      flux = min(flux, cap[t[nod]][nod]);
      nod = t[nod];
    }
    max_flow += flux;
    nod = n + m + 2;
    while (nod != 1)
    {
      cap[t[nod]][nod] -= flux;
      cap[nod][t[nod]] += flux;
      nod = t[nod];
    }
    ans += flux * pr[n + m + 2];
    for (int i = 1; i <= n + m + 2; i++)
    {
      aux[i] = d[i];
    }
  }
  out << max_flow << " " << ans << '\n';
  for (int i = 0; i < muchii.size(); i++)
  {
    int x = muchii[i].first, y = muchii[i].second;
    if (cap[x + 1][y + n + 1] < INF)
    {
      out << i + 1 << " ";
    }
  }
  in.close();
  out.close();
  return 0;
}