Dinic模板

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <string>
#include <cstring>
#include <cmath>
#include <vector>
#include <queue>
#include <algorithm>
#include <map>
using namespace std;

struct Edge
{
	int from, to, cap, flow;
	Edge(int from, int to, int cap, int flow): from(from), to(to), cap(cap), flow(flow) {}
};

const int maxn = 110;
const int INF = 0x3f3f3f3f;

struct Dinic
{
	int n, m, s, t;
	vector<Edge> edges;
	vector<int> G[maxn];
	bool vis[maxn];
	int d[maxn];
	int cur[maxn];
	
	bool vis1[maxn], vis2[maxn];
	
	void init(int n)
	{
		this->n = n;
		for(int i = 0; i < n; i++) G[i].clear();
		edges.clear();
		memset(vis1, 0, sizeof(vis1));
		memset(vis2, 0, sizeof(vis2));
	}
	
	void ClearFlow()
	{
		for(int i = 0; i < edges.size(); i++) edges[i].flow = 0;
	}
	
	void AddEdge(int from, int to, int cap)
	{
		edges.push_back(Edge(from, to, cap, 0));
		edges.push_back(Edge(to, from, 0, 0));
		m = edges.size();
		G[from].push_back(m-2);
		G[to].push_back(m-1);
	}
	
	bool bfs()
	{
		memset(vis, 0, sizeof(vis));
		queue<int> Q;
		Q.push(s);
		d[s] = 0;
		vis[s] = 1;
		while(!Q.empty())
		{
			int x = Q.front(); Q.pop();
			for(int i = 0; i < G[x].size(); i++)
			{
				Edge&e = edges[G[x][i]];
				if(!vis[e.to] && e.cap > e.flow)
				{
					vis[e.to] = 1;
					d[e.to] = d[x] + 1;
					Q.push(e.to);
				}
			}
		}
		return vis[t];
	}
	
	int dfs(int x, int a)
	{
		if(x == t || a == 0) return a;
		int flow = 0, f;
		for(int &i = cur[x]; i < G[x].size(); i++)
		{
			Edge&e = edges[G[x][i]];
			if(d[x]+1 == d[e.to] && (f = dfs(e.to, min(a, e.cap-e.flow))) > 0)
			{
				e.flow += f;
				edges[G[x][i]^1].flow -= f;
				flow += f;
				a -= f;
				if(a == 0) break;
			}
		}
		return flow;
	}
	
	int Maxflow(int s, int t)
	{
		this->s = s; this->t = t;
		int flow = 0;
		while(bfs())
		{
			memset(cur, 0, sizeof(cur));
			flow += dfs(s, INF);
		}
		return flow;
	}
	  
void dfs1(int u)
{
	vis1[u] = 1;
		for(int i = 0; i < G[u].size(); i++)
	{
		Edge&e = edges[G[u][i]];
		if(!vis1[e.to] && e.cap - e.flow > 0)
		{
			dfs1(e.to);
		}
	}
}

void dfs2(int u)
{
	vis2[u] = 1;
	for(int i = 0; i < G[u].size(); i++)
	{
		Edge &e = edges[G[u][i]^1];
		if(!vis2[e.from] && e.cap > e.flow)
		{
			dfs2(e.from);
		}
	}
}

};

Dinic solver;
int n, m, L;
int s, t;

int read_case()
{
	scanf("%d%d%d", &n, &m, &L);
	if(!n) return 0;
	solver.init(n+m+3);
	for(int i = 0; i < L; i++)
	{
		int from, to, cap;
		scanf("%d%d%d", &from, &to, &cap);
		solver.AddEdge(from, to, cap);
	}
	s = n+m+1, t = 0;
	for(int i = 1; i <= n; i++) solver.AddEdge(s, i, INF);
	solver.Maxflow(s, t);
	return 1;
}

void solve()
{
	solver.dfs1(s);
	solver.dfs2(t);
	int first = 1;
	for(int i = 0; i < solver.m; i+=2)
	{
		Edge&e = solver.edges[i];
		if(solver.vis1[e.from] && solver.vis2[e.to] && e.cap == e.flow)
		{
			if(first) { printf("%d", i/2+1); first = 0;}
			else printf(" %d", i/2+1);
		}
	}
	if(first) printf("\n");
	printf("\n");
}

int main()
{
	while(read_case())
	{
		solve();
	}
	return 0;
}