private void markPath(V v, V child, V stem, Set<V> blossom) {
while (!contracted.get(v).equals(stem)) {
blossom.add(contracted.get(v));
blossom.add(contracted.get(match.get(v)));
path.put(v, child);
child = match.get(v);
v = path.get(match.get(v));
}
}
/**
* Runs the algorithm on the input graph and returns the match edge set.
*
* @return set of Edges
*/
private Set<E> findMatch() {
Set<E> result = new ArrayUnenforcedSet<>();
match = new HashMap<>();
path = new HashMap<>();
contracted = new HashMap<>();
for (V i : graph.vertexSet()) {
// Any augmenting path should start with _exposed_ vertex
// (vertex may not escape match-set being added once)
if (!match.containsKey(i)) {
// Match is maximal iff graph G contains no more augmenting paths
V v = findPath(i);
while (v != null) {
V pv = path.get(v);
V ppv = match.get(pv);
match.put(v, pv);
match.put(pv, v);
v = ppv;
}
}
}
Set<V> seen = new HashSet<>();
graph
.vertexSet()
.stream()
.filter(v -> !seen.contains(v) && match.containsKey(v))
.forEach(
v -> {
seen.add(v);
seen.add(match.get(v));
result.add(graph.getEdge(v, match.get(v)));
});
return result;
}
private V findPath(V root) {
Set<V> used = new HashSet<>();
Queue<V> q = new ArrayDeque<>();
// Expand graph back from its contracted state
path.clear();
contracted.clear();
graph.vertexSet().forEach(vertex -> contracted.put(vertex, vertex));
used.add(root);
q.add(root);
while (!q.isEmpty()) {
V v = q.remove();
for (E e : graph.edgesOf(v)) {
V to = graph.getEdgeSource(e);
if (to.equals(v)) {
to = graph.getEdgeTarget(e);
}
if ((contracted.get(v).equals(contracted.get(to))) || to.equals(match.get(v))) {
continue;
}
// Check whether we've hit a 'blossom'
if ((to.equals(root)) || ((match.containsKey(to)) && (path.containsKey(match.get(to))))) {
V stem = lowestCommonAncestor(v, to);
Set<V> blossom = new HashSet<>();
markPath(v, to, stem, blossom);
markPath(to, v, stem, blossom);
graph
.vertexSet()
.stream()
.filter(i -> contracted.containsKey(i) && blossom.contains(contracted.get(i)))
.forEach(
i -> {
contracted.put(i, stem);
if (!used.contains(i)) {
used.add(i);
q.add(i);
}
});
// Check whether we've had hit a loop (of even length (!) presumably)
} else if (!path.containsKey(to)) {
path.put(to, v);
if (!match.containsKey(to)) {
return to;
}
to = match.get(to);
used.add(to);
q.add(to);
}
}
}
return null;
}
public void testCornerCases() {
DirectedWeightedMultigraph<Integer, DefaultWeightedEdge> simple =
new DirectedWeightedMultigraph<>(DefaultWeightedEdge.class);
simple.addVertex(0);
simple.addVertex(1);
DefaultWeightedEdge e = simple.addEdge(0, 1);
try {
new EdmondsKarpMFImpl<Integer, DefaultWeightedEdge>(null);
fail();
} catch (NullPointerException ex) {
}
try {
new EdmondsKarpMFImpl<>(simple, -0.1);
fail();
} catch (IllegalArgumentException ex) {
}
try {
simple.setEdgeWeight(e, -1.0);
new EdmondsKarpMFImpl<>(simple);
fail();
} catch (IllegalArgumentException ex) {
}
try {
simple.setEdgeWeight(e, 1.0);
MaximumFlowAlgorithm<Integer, DefaultWeightedEdge> solver = new EdmondsKarpMFImpl<>(simple);
Map<DefaultWeightedEdge, Double> flow = solver.buildMaximumFlow(0, 1).getFlow();
flow.put(e, 25.0);
fail();
} catch (UnsupportedOperationException ex) {
}
try {
MaximumFlowAlgorithm<Integer, DefaultWeightedEdge> solver = new EdmondsKarpMFImpl<>(simple);
solver.buildMaximumFlow(2, 0);
fail();
} catch (IllegalArgumentException ex) {
}
try {
MaximumFlowAlgorithm<Integer, DefaultWeightedEdge> solver = new EdmondsKarpMFImpl<>(simple);
solver.buildMaximumFlow(1, 2);
fail();
} catch (IllegalArgumentException ex) {
}
try {
MaximumFlowAlgorithm<Integer, DefaultWeightedEdge> solver = new EdmondsKarpMFImpl<>(simple);
solver.buildMaximumFlow(0, 0);
fail();
} catch (IllegalArgumentException ex) {
}
try {
MaximumFlowAlgorithm<Integer, DefaultWeightedEdge> solver = new EdmondsKarpMFImpl<>(simple);
solver.buildMaximumFlow(null, 0);
fail();
} catch (IllegalArgumentException ex) {
}
try {
MaximumFlowAlgorithm<Integer, DefaultWeightedEdge> solver = new EdmondsKarpMFImpl<>(simple);
solver.buildMaximumFlow(0, null);
fail();
} catch (IllegalArgumentException ex) {
}
}