/*
    ** Code by Andrei Arhire
    ** Tecuci , Galati
*/
#include <bits/stdc++.h>
#define pb push_back
#define s second
#define f first
#define it vector < pair < int , int > > :: iterator
using namespace std ;
const int NR = 700 , oo = ( 1 << 30 ) ;
ifstream in ("cmcm.in") ;
ofstream out ("cmcm.out") ;
int source , sink , capacity , z , x , y , st , dr , e , nr ;
int64_t ans ;
int cost [ NR ][ NR ] , cap [ NR ][ NR ] , t [ NR ] , edge [ NR ] ;
vector < pair < int , int > > v [ NR ] ;
vector < int > d_old ( NR , oo ) , d_dij ( NR , oo ) , d_new ( NR , oo ) ;
struct cmp  {
inline bool operator ()( pair < int , int > i , pair < int , int > j )    {
return i.s > j.s ;
}
};
priority_queue < pair < int , int > , vector < pair < int , int > > , cmp > q ;
bitset < NR > inq ;
bitset < 50005 > isedge ;
bool dijkstra (  )  {
    int nod , i , c ;
    for ( i = 1 ; i <= st + dr + 1 ; ++ i )   d_dij [ i ] = oo ;
    d_dij [ source ] = 0 ;
    d_new [ source ] = 0 ;
    q.push( { source , 0 } ) ;
    while ( !q.empty() )    {
        nod = q.top().f ;
        c = q.top().s ;
        q.pop() ;
        if ( c != d_dij [ nod ] )   continue ;
        for ( it i = v [ nod ].begin() ; i < v [ nod ].end() ; ++ i )   {
            if ( cap [ nod ][ (*i).f ] )    {
                if ( d_dij [ nod ] + ( d_old [ nod ] + cost [ nod ][ (*i).f ] - d_old [ (*i).f ] ) < d_dij [ (*i).f ] ) {
                    d_dij [ (*i).f ] = d_dij [ nod ] + ( d_old [ nod ] + cost [ nod ][ (*i).f ] - d_old [ (*i).f ] ) ;
                    d_new [ (*i).f ] = d_new [ nod ] + cost [ nod ][ (*i).f ] ;
                    t [ (*i).f ] = nod ;
                    edge [ (*i).f ] = (*i).s ;
                    q.push( { (*i).f , d_dij [ (*i).f ] } ) ;
                }
            }
        }
    }
    if ( d_dij [ sink ] == oo ) return 0 ;
    for ( i = sink ; i != source ; i = t [ i ] )    {

        cap [ t [ i ] ][ i ] = 0 ;
        cap [ i ][ t [ i ] ] = 1 ;
        if ( isedge [ edge [ i ] ] )    isedge [ edge [ i ] ] = 0 ;
        else                            isedge [ edge [ i ] ] = 1 ;

    }
    for ( i = 1 ; i <= st + dr + 1 ; ++ i )   d_old [ i ] = d_new [ i ] ;
    ans += d_new [ sink ] ;
    nr ++ ;
    return 1 ;
}
void bellman ( )    {
    int nod ;
        d_old [ source ] = 0 ;
        queue < int > q ;
        q.push( source ) ;
    while ( !q.empty() ) {
        nod = q.front() ;
        q.pop() ;
        inq [ nod ] = 0 ;
        for ( it i = v [ nod ].begin() ; i != v [ nod ].end() ; ++ i )  {
            if ( cap [ nod ][ (*i).f ] )
                if ( d_old [ nod ] + cost [ nod ][ (*i).f ] < d_old [ (*i).f ] )  {
                    d_old [ (*i).f ] = d_old [ nod ] + cost [ nod ][ (*i).f ] ;
                    if ( !inq [ (*i).f ] )
                        q.push( (*i).f ) ,
                        inq [ (*i).f ] = 1 ;
                }
            }
    }
}
int main () {

    int i ;
    in >> st >> dr >> e ;
    sink = st + dr + 1 ;
     for ( i = 1 ; i <= e ; ++ i )  {
        in >> x >> y >> z ;
        cap [ x ][ y + st ] = 1 ;
        cost [ x ][ y + st ] = z ;
        cost [ y + st ][ x ] = -z ;
        v [ x ].pb ( { y + st , i } ) ;
        v [ y + st ].pb ( { x , i } ) ;
    }
    for ( i = 1 ; i <= st ; ++ i )  {
        cap [ 0 ][ i ] = 1 ;
        v [ 0 ].pb ( { i , 0 } ) ;
        v [ i ].pb ( { 0 , 0 } ) ;
    }
    for ( i = 1 ; i <= dr ; ++ i )  {
        cap [ st + i ][ sink ] = 1 ;
        v [ st + i ].pb ( { sink , 0 } ) ;
        v [ sink ].pb ( { st + i , 0 } ) ;
    }
    int a = 0 , b = 0 ;
    bellman() ;
    while ( dijkstra() ) ;
    out << nr << ' ' << ans << '\n' ;
    for ( i = 1 ; i <= e ; ++ i )   if ( isedge [ i ] ) out << i << ' ' ;
}