#include <bits/stdc++.h>

using namespace std;

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

vector <int> v[310];
int N,maxflow,cost_total,indice[310][310],dist[310],min_dist[310],cost[310][310],tata[310],C[310][310],new_dist[310],flux[310][310];
queue <int> q;
priority_queue < pair <int,int> , vector < pair <int,int> > , greater < pair <int,int > > > h;

void Bellman_Ford()
{
    int i,nod;
    for(i=0;i<=N;i++)dist[i]=INT_MAX/2;
    q.push(0);dist[0]=0;
    while(!q.empty())
    {
        nod=q.front();
        q.pop();
        for(int i=0;i<v[nod].size();i++)
        {
            int vecin=v[nod][i];
            if(flux[nod][vecin] < C[nod][vecin] && dist[vecin] > dist[nod]+cost[nod][vecin])
            {
                dist[vecin]=dist[nod]+cost[nod][vecin];
            }
        }
    }
}

int Dijkstra()
{
    int i,nod,flux_min;
    for(i=0;i<=N;i++)min_dist[i]=INT_MAX/2,tata[i]=-1;
    min_dist[0]=0;new_dist[0]=0;
    h.push({0,0});
    while(!h.empty())
    {
        int nod=h.top().second;
        if(min_dist[nod] < h.top().first){h.pop();continue;}
        else h.pop();

        for(int i=0;i<v[nod].size();i++)
        {
            int vecin=v[nod][i];
            int cost_intre=cost[nod][vecin]+dist[nod]-dist[vecin];
            if(flux[nod][vecin] < C[nod][vecin] && min_dist[vecin] > min_dist[nod]+cost_intre)
            {
                min_dist[vecin]=min_dist[nod]+cost_intre;
                new_dist[vecin]=new_dist[nod]+cost[nod][vecin];
                tata[vecin]=nod;
                h.push({min_dist[vecin],vecin});
            }
        }
    }

    if(min_dist[N]==INT_MAX/2)return 0;

    flux_min=1;
    nod=N;
    while(tata[nod]!=-1)
    {
        flux[tata[nod]][nod]+=flux_min;
        flux[nod][tata[nod]]-=flux_min;
        nod=tata[nod];
    }

    maxflow+=flux_min;
    cost_total+=flux_min*new_dist[N];

    for(i=0;i<=N;i++)dist[i]=new_dist[i];

    return 1;
}

int n,m,e,x,i,y,ct;
int main()
{
    f>>n>>m>>e;
    N=n+m+1;

    for(i=1;i<=e;i++)
    {
        f>>x>>y>>ct;y+=n;

        v[x].push_back(y);
        v[y].push_back(x);
        C[x][y]=1;
        cost[x][y]=ct;cost[y][x]=-ct;
        indice[x][y]=i;indice[y][x]=i;
    }

    for(i=1;i<=n;i++)
    {
        v[0].push_back(i);
        v[i].push_back(0);
        C[0][i]=1;
    }

    for(i=n+1;i<N;i++)
    {
        v[i].push_back(N);
        v[N].push_back(i);
        C[i][N]=1;
    }

    Bellman_Ford();
    while(Dijkstra());

    g<<maxflow<<" "<<cost_total<<'\n';
    for(i=1;i<=n;i++)
    {
        for(int j=0;j<v[i].size();j++)
        {
            int vecin=v[i][j];
            if(flux[i][vecin]==1)g<<indice[i][vecin]<<" ";
        }
    }
    return 0;
}