#include <queue>
#include <cstdlib>
#include <fstream>
#define Nmax 711
#define oo 100000000

/*
 *
 */
using namespace std;
struct vertex
{
    int y, c, f, d, idx;
    vertex *next, *inv;
    vertex( void ) : y(0), c(0), f(0), d(oo), next(NULL), inv(NULL) {}
} *G[Nmax], *fp[Nmax];
int N, M, sink=700, source;
int d[Nmax];
bool inH[Nmax];
class cmp
{
public:
    bool operator() ( const int& x, const int& y )
    {
        return d[x] > d[y];
    }
};
priority_queue< int, vector< int >, cmp > pQ;
inline void Add( int x, int y, int d, int idx=0 )
{
    vertex *p=new vertex, *q=new vertex;
    p->y=x;             q->y=y;
    p->c=0;             q->c=1;
    p->idx=0;           q->idx=idx;
    p->d=-d;            q->d=d;
    p->next=G[y];       q->next=G[x];
    G[y]=p;             G[x]=q;
    G[y]->inv=G[x];     G[x]->inv=G[y];
}
bool MinPath( void )
{
    int x;
    vertex *p;
    for( x=1; x <= N+M+1; ++x )
        d[x]=oo, inH[x]=false;
    d[sink]=oo;
    inH[sink]=false;
    d[source]=0;
    fp[source]=NULL;
    for( pQ.push(source); !pQ.empty(); )
    {
        x=pQ.top(); pQ.pop();
        inH[x]=false;
        for( p=G[x]; NULL != p; p=p->next )
            if( p->c > p->f && d[p->y] > d[x]+p->d )
            {
                fp[p->y]=p;
                d[p->y]=d[x]+p->d;
                if( false == inH[p->y] )
                {
                    pQ.push(p->y);
                    inH[p->y]=true;
                }
            }
    }
    return oo != d[sink];
}
int main( void )
{
    vertex *p;
    int E, x, y, dd;
    ifstream in( "cmcm.in" );
    in>>N>>M>>E;
    for( int idx=1; E; --E, ++idx )
    {
        in>>x>>y>>dd;
        y+=N+1;
        Add( x, y, dd, idx );
        if( false == inH[x] )
        {
            Add( source, x, 0 );
            inH[x]=true;
        }
        if( false == inH[y] )
        {
            Add( y, sink, 0 );
            inH[y]=true;
        }
    }
    for( x=y=0; MinPath(); ++x, y+=d[sink] )
    {
        for( p=fp[sink]; p; p=fp[p->inv->y] )
            ++p->f, --p->inv->f;
    }
    ofstream out( "cmcm.out" );
    out<<x<<' '<<y<<'\n';
    for( y=1; y <= N && x; ++y )
    {
        for( p=G[y]; p; p=p->next )
            if( p->f > 0 )
            {
                --x;
                out<<p->idx<<'\n';
                break;
            }
    }
    return EXIT_SUCCESS;
}