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

using namespace std;

const int inf=1000000000;
struct heap
{
    int nod,c;
    bool operator <(const heap &aux) const
    {
        return c>aux.c;
    }
};
vector<int> v[610];
queue<int> q;
priority_queue<heap> h;
pair<int,int> edge[50010];
int cost[610][610],dist[610],dist1[610],cap[610][610],flow[610][610],d[610],tata[610],sursa,dest,n;
char vaz[610];

void bellman_ford(int nod)
{
    for(int i=sursa;i<=dest;i++) dist[i]=inf;
    dist[nod]=0;
    q.push(nod);
    vaz[nod]=1;
    while(!q.empty())
    {
        int nod=q.front();q.pop();
        vaz[nod]=0;
        for(vector<int>::iterator it=v[nod].begin();it!=v[nod].end();it++)
            if(cap[nod][*it] && dist[*it]>dist[nod]+cost[nod][*it])
            {
                dist[*it]=dist[nod]+cost[nod][*it];
                if(!vaz[*it] && *it!=dest)
                {
                    vaz[*it]=1;
                    q.push(*it);
                }
            }
    }
}

int dijkstra()
{
    for(int i=sursa;i<=dest;i++) d[i]=dist1[i]=inf;
    d[sursa]=dist1[sursa]=0;
    h.push({sursa,0});
    while(!h.empty())
    {
        int nod=h.top().nod,c=h.top().c;
        h.pop();
        if(d[nod]!=c) continue;
        for(vector<int>::iterator it=v[nod].begin();it!=v[nod].end();it++)
            if(cap[nod][*it]>flow[nod][*it] && d[*it]>d[nod]+cost[nod][*it]+dist[nod]-dist[*it])
            {
                d[*it]=d[nod]+cost[nod][*it]+dist[nod]-dist[*it];
                dist1[*it]=dist1[nod]+cost[nod][*it];
                tata[*it]=nod;
                if(*it!=dest) h.push({*it,d[*it]});
            }
    }
    for(int i=sursa;i<=dest;i++) dist[i]=dist1[i];
    return d[dest]!=inf;
}

int main()
{
    freopen("cmcm.in", "r", stdin);
    freopen("cmcm.out", "w", stdout);
    int m,x,y,a,c,sol=0,flux=0,e;
    scanf("%d%d%d",&n,&m,&e);
    for(int i=1;i<=e;i++)
    {
        scanf("%d%d%d",&x,&y,&c);
        edge[i]={x,y};
        v[x].push_back(n+y);
        v[n+y].push_back(x);
        cap[x][n+y]=1;
        cost[x][n+y]=c;
        cost[n+y][x]=-c;
    }
    sursa=0;dest=n+m+1;
    for(int i=1;i<=n;i++)
    {
        v[sursa].push_back(i);
        v[i].push_back(sursa);
        cap[sursa][i]=1;
    }
    for(int i=1;i<=m;i++)
    {
        v[n+i].push_back(dest);
        v[dest].push_back(n+i);
        cap[n+i][dest]=1;
    }
    bellman_ford(sursa);
    while(dijkstra())
    {
        for(int i=dest;i!=sursa;i=tata[i])
        {
            flow[tata[i]][i]++;
            flow[i][tata[i]]--;
        }
        sol+=dist[dest];
        flux++;
    }
    printf("%d %d\n",flux,sol);
    for(int i=1;i<=e;i++)
        if(flow[edge[i].first][n+edge[i].second]) printf("%d ",i);
    return 0;
}