ref: 4408476b7584b9a316466fe1bd10867103cddf57
dir: /maxflow.h/
/* * Edmonds-Karp algorithm for finding a maximum flow and minimum * cut in a network. Almost identical to the Ford-Fulkerson * algorithm, but apparently using breadth-first search to find the * _shortest_ augmenting path is a good way to guarantee * termination and ensure the time complexity is not dependent on * the actual value of the maximum flow. I don't understand why * that should be, but it's claimed on the Internet that it's been * proved, and that's good enough for me. I prefer BFS to DFS * anyway :-) */ #ifndef MAXFLOW_MAXFLOW_H #define MAXFLOW_MAXFLOW_H /* * The actual algorithm. * * Inputs: * * - `scratch' is previously allocated scratch space of a size * previously determined by calling `maxflow_scratch_size'. * * - `nv' is the number of vertices. Vertices are assumed to be * numbered from 0 to nv-1. * * - `source' and `sink' are the distinguished source and sink * vertices. * * - `ne' is the number of edges in the graph. * * - `edges' is an array of 2*ne integers, giving a (source, dest) * pair for each network edge. Edge pairs are expected to be * sorted in lexicographic order. * * - `backedges' is an array of `ne' integers, each a distinct * index into `edges'. The edges in `edges', if permuted as * specified by this array, should end up sorted in the _other_ * lexicographic order, i.e. dest taking priority over source. * * - `capacity' is an array of `ne' integers, giving a maximum * flow capacity for each edge. A negative value is taken to * indicate unlimited capacity on that edge, but note that there * may not be any unlimited-capacity _path_ from source to sink * or an assertion will be failed. * * Output: * * - `flow' must be non-NULL. It is an array of `ne' integers, * each giving the final flow along each edge. * * - `cut' may be NULL. If non-NULL, it is an array of `nv' * integers, which will be set to zero or one on output, in such * a way that: * + the set of zero vertices includes the source * + the set of one vertices includes the sink * + the maximum flow capacity between the zero and one vertex * sets is achieved (i.e. all edges from a zero vertex to a * one vertex are at full capacity, while all edges from a * one vertex to a zero vertex have no flow at all). * * - the returned value from the function is the total flow * achieved. */ int maxflow_with_scratch(void *scratch, int nv, int source, int sink, int ne, const int *edges, const int *backedges, const int *capacity, int *flow, int *cut); /* * The above function expects its `scratch' and `backedges' * parameters to have already been set up. This allows you to set * them up once and use them in multiple invocates of the * algorithm. Now I provide functions to actually do the setting * up. */ int maxflow_scratch_size(int nv); void maxflow_setup_backedges(int ne, const int *edges, int *backedges); /* * Simplified version of the above function. All parameters are the * same, except that `scratch' and `backedges' are constructed * internally. This is the simplest way to call the algorithm as a * one-off; however, if you need to call it multiple times on the * same network, it is probably better to call the above version * directly so that you only construct `scratch' and `backedges' * once. * * Additional return value is now -1, meaning that scratch space * could not be allocated. */ int maxflow(int nv, int source, int sink, int ne, const int *edges, const int *capacity, int *flow, int *cut); #endif /* MAXFLOW_MAXFLOW_H */