#include <cstdio>
#include <cstring>
#include <vector>
#include <queue>

using namespace std;

const int NMAX = 602;
const int INF = 2000000000;

#define x second
#define t first

int  st, fin;
int cost[NMAX + 1][NMAX + 1], cap[NMAX + 1][NMAX + 1];
int dv[NMAX + 1], d[NMAX + 1], dr[NMAX + 1], t[NMAX + 1];
bool inQ[NMAX + 1];

vector <int> v[NMAX + 1], vn[NMAX + 1];
queue <int> q;
priority_queue <pair <int, int>, vector <pair <int, int> >, greater <pair <int, int> > > h;


void bfs ()
{
    for (int i = 0; i < NMAX; ++i)
        dv[i] = INF;
    dv[st] = 0;
    q.push (st);
    inQ[st] = true;

    while (!q.empty ())
    {
        int nod = q.front ();
        q.pop ();
        inQ[nod] = false;

        for (int i = 0; i < v[nod].size (); ++i)
        {
            int fiu = v[nod][i];
            if (cap[nod][fiu] && dv[nod] + cost[nod][fiu] < dv[fiu])
            {
                dv[fiu] = dv[nod] + cost[nod][fiu];
                if (!inQ[fiu])
                {
                    inQ[fiu] = true;
                    q.push (fiu);
                }
            }
        }
    }
}

bool dijkstra ()
{
    memset(d, 0x3f, sizeof(d));
    d[st] = dr[st] = 0;
    h.push (make_pair (0, st));

    while (!h.empty ())
    {
        pair<int, int> nod = h.top ();
        h.pop ();
        if (d[nod.x] != nod.t) continue;

        for (int i = 0; i < v[nod.x].size (); ++i)
        {
            int fiu = v[nod.x][i];
            if (cap[nod.x][fiu])
            {
                int dfiu = d[nod.x] + cost[nod.x][fiu] + dv[nod.x] - dv[fiu];
                if (dfiu < d[fiu])
                {
                    d[fiu] = dfiu;
                    dr[fiu] = dr[nod.x] + cost[nod.x][fiu];
                    t[fiu] = nod.x;
                    h.push (make_pair (dfiu, fiu));
                }
            }
        }
    }

    memcpy (dv, dr, sizeof (dr));
    return d[fin] != 0x3f3f3f3f;
}

int main ()
{
    freopen ("cmcm.in", "r", stdin);
    freopen ("cmcm.out", "w", stdout);
    int n, m, e, x, y;
    int flux = 0, costFlux = 0;

    scanf ("%d%d%d", &n, &m, &e);
    for (int i = 1; i <= e; ++i)
    {
        scanf ("%d%d", &x, &y);
        y += 300;
        scanf ("%d", &cost[x][y]);
        cap[x][y] = 1;
        cost[y][x] = -cost[x][y];
        v[x].push_back (y);
        v[y].push_back (x);
        vn[x].push_back (i);
        vn[y].push_back (i);
    }
    st = 601;
    fin = 602;
    for (int i = 1; i <= n; ++i)
    {
        cap[st][i] = 1;
        v[st].push_back (i);
        v[i].push_back (st);
    }
    for (int i = 1; i <= m; ++i)
    {
        cap[i + 300][fin] = 1;
        v[fin].push_back (i + 300);
        v[i + 300].push_back (fin);
    }

    bfs ();

    while (dijkstra ())
    {
        int mini = INF;

        for (int nod = fin; nod != st; nod = t[nod])
            mini = min (mini, cap[t[nod]][nod]);
        for (int nod = fin; nod != st; nod = t[nod])
        {
            cap[t[nod]][nod] -= mini;
            cap[nod][t[nod]] += mini;
        }

        flux += mini;
        costFlux += mini * dr[fin];
    }

    printf ("%d %d\n", flux, costFlux);
    for (int i = 1; i <= n; ++i)
    {
        for (int j = 0; j < v[i].size (); ++j)
        {
            if (v[i][j] != st && cap[i][v[i][j]] == 0)
                printf ("%d ", vn[i][j]);
        }
    }

    return 0;
}