#include <fstream>
#include <cstring>
#include <vector>
#include <queue>
using namespace std;

const int N = 603, QSize = (1 << 10) - 1, inf = 0x3f3f3f3f;

class Queue{
    int v[QSize + 1], st, dr;
    bool use[N];

public:
    Queue(){
        st = dr = 0;
    }

    inline void push(int x){
        if (!use[x]){
            v[dr] = x;
            use[x] = true;
            dr = (dr + 1) & QSize;
        }
    }

    inline int pop(){
        int x = v[st];
        st = (st + 1) & QSize;
        use[x] = false;
        return x;
    }

    inline bool isEmpty(){
        return st == dr;
    }
};

struct Edge{
    int y, c;

    Edge(int y, int c) :
        y(y),
        c(c)
    {}
};

vector<Edge> graph[N];
int cf[N][N], dist[N], T[N], n;
int edgeIndex[N][N];
Queue Q;

inline void relax(int x, int y, int F){
    cf[x][y] -= F;
    cf[y][x] += F;
}

inline void addEdge(int x, int y, int c){
    graph[x].push_back( Edge(y, c) );
    graph[y].push_back( Edge(x, -c) );
    cf[x][y] = 1;
}

bool bellmaxFord(int x, int D){
    memset(dist, inf, sizeof(dist));
    memset(T, 0, sizeof(T));
    dist[x] = 0;
    Q.push(x);

    while ( !Q.isEmpty() ){
        x = Q.pop();

        for (Edge E : graph[x])
            if ( cf[x][E.y] && dist[x] + E.c < dist[E.y]){
                dist[E.y] = dist[x] + E.c;
                Q.push(E.y);
                T[E.y] = x;
            }
    }

    return dist[D] != inf;
}

void maxFlow(int S, int D, int& flow, int& cost){
    flow = cost = 0;
    while ( bellmaxFord(S, D) ){
        int F = inf;
        for (int i = D ; i != S ; i = T[i])
            F = min(F, cf[ T[i] ][i]);
        for (int i = D ; i != S ; i = T[i])
            relax(T[i], i, F);

        cost += F * dist[D];
        flow += F;
    }
}

int main(){
    int A, B, m, x, y, c, S, D, F, C;
    ifstream in("cmcm.in");

    in >> A >> B >> m;
    for (int i = 1 ; i <= m ; i++){
        in >> x >> y >> c;
        addEdge(x, y + A, c);
        edgeIndex[x][y + A] = i;
    }

    in.close();

    S = 0;
    D = A + B + 1;
    for (int i = 1 ; i <= A ; i++)
        addEdge(S, i, 0);
    for (int i = 1 ; i <= B ; i++)
        addEdge(i + A, D, 0);

    ofstream out("cmcm.out");

    maxFlow(S, D, F, C);

    out << F << ' ' << C << '\n';
    for (int i = 1 ; i <= A ; i++)
        for (int j = A + 1 ; j <= A + B ; j++)
            if ( edgeIndex[i][j] && !cf[i][j] )
                out << edgeIndex[i][j] << ' ';
    out << '\n';

    out.close();

    return 0;
}