//=======================================================================
// This is a breadth-first search over the residual graph
// (well, actually the reverse of the residual graph).
// Would be cool to have a graph view adaptor for hiding certain
// edges, like the saturated (non-residual) edges in this case.
// Goldberg's implementation abused "distance" for the coloring.
private void GlobalDistanceUpdate()
{
foreach (IVertex u in VisitedGraph.Vertices)
{
Colors[u] = GraphColor.White;
Distances[u] = n;
}
Distances[sink] = 0;
for (int l = 0; l <= maxDistance; ++l)
{
layers[l].ActiveVertices.Clear();
layers[l].InactiveVertices.Clear();
}
maxDistance = maxActive = 0;
minActive = n;
BreadthFirstSearchAlgorithm bfs = new BreadthFirstSearchAlgorithm(
ResidualGraph,
new VertexBuffer(),
Colors
);
DistanceRecorderVisitor vis = new DistanceRecorderVisitor(Distances);
bfs.TreeEdge += new EdgeEventHandler(vis.TreeEdge);
bfs.DiscoverVertex += new VertexEventHandler(GlobalDistanceUpdateHelper);
bfs.Compute(sink);
}
void SearchGraph(
BidirectionalGraph <Vertex, SEdge <Vertex> > graph,
VertexPredecessorRecorderObserver <Vertex, SEdge <Vertex> >
observer = null
)
{
BreadthFirstSearchAlgorithm <Vertex, SEdge <Vertex> > bfs =
new BreadthFirstSearchAlgorithm <Vertex, SEdge <Vertex> >
(graph);
if (observer == null)
{
bfs.Compute();
}
else
{
using (observer.Attach(bfs)) {
bfs.Compute();
foreach (
KeyValuePair <Vertex, SEdge <Vertex> > pair in
observer.VerticesPredecessors
)
{
Debug.Log(
pair.Value.Source.Point +
" -> " +
pair.Value.Target.Point
);
}
}
}
}
public void GraphWithSelfEdgesPUT1(int v, int e, bool self)
{
AdjacencyGraph g = null;
RandomGraph.Graph(g, v, e, new Random(), self);
BreadthFirstSearchAlgorithm bfs = new BreadthFirstSearchAlgorithm(g);
}
public void SetRootVertex_Throws()
{
var graph = new AdjacencyGraph <TestVertex, Edge <TestVertex> >();
var algorithm = new BreadthFirstSearchAlgorithm <TestVertex, Edge <TestVertex> >(graph);
SetRootVertex_Throws_Test(algorithm);
}
private void GenerateSpanningTree()
{
_spanningTree = new BidirectionalGraph <TVertex, Edge <TVertex> >(false);
_spanningTree.AddVertexRange(VisitedGraph.Vertices);
IQueue <TVertex> vb = new QuikGraph.Collections.Queue <TVertex>();
vb.Enqueue(VisitedGraph.Vertices.OrderBy(v => VisitedGraph.InDegree(v)).First());
switch (Parameters.SpanningTreeGeneration)
{
case SpanningTreeGeneration.BFS:
var bfs = new BreadthFirstSearchAlgorithm <TVertex, TEdge>(VisitedGraph, vb, new Dictionary <TVertex, GraphColor>());
bfs.TreeEdge += e =>
{
ThrowIfCancellationRequested();
_spanningTree.AddEdge(new Edge <TVertex>(e.Source, e.Target));
};
bfs.Compute();
break;
case SpanningTreeGeneration.DFS:
var dfs = new DepthFirstSearchAlgorithm <TVertex, TEdge>(VisitedGraph);
dfs.TreeEdge += e =>
{
ThrowIfCancellationRequested();
_spanningTree.AddEdge(new Edge <TVertex>(e.Source, e.Target));
};
dfs.Compute();
break;
}
}
public static TryFunc <TVertex, IEnumerable <TEdge> > TreeBreadthFirstSearch <TVertex, TEdge>(
#if !NET20
this
#endif
IVertexListGraph <TVertex, TEdge> visitedGraph,
TVertex root)
where TEdge : IEdge <TVertex>
{
Contract.Requires(visitedGraph != null);
Contract.Requires(root != null);
Contract.Requires(visitedGraph.ContainsVertex(root));
Contract.Ensures(Contract.Result <TryFunc <TVertex, IEnumerable <TEdge> > >() != null);
var algo = new BreadthFirstSearchAlgorithm <TVertex, TEdge>(visitedGraph);
var predecessorRecorder = new VertexPredecessorRecorderObserver <TVertex, TEdge>();
using (predecessorRecorder.Attach(algo))
algo.Compute(root);
var predecessors = predecessorRecorder.VertexPredecessors;
return(delegate(TVertex v, out IEnumerable <TEdge> edges)
{
return EdgeExtensions.TryGetPath(predecessors, v, out edges);
});
}
public void ClearRootVertex()
{
var graph = new AdjacencyGraph <int, Edge <int> >();
var algorithm = new BreadthFirstSearchAlgorithm <int, Edge <int> >(graph);
ClearRootVertex_Test(algorithm);
}
public void ExamineEdge(Object sender, EdgeEventArgs args)
{
Assert.IsTrue(sender is BreadthFirstSearchAlgorithm);
BreadthFirstSearchAlgorithm algo = (BreadthFirstSearchAlgorithm)sender;
Assert.AreSame(args.Edge.Source, CurrentVertex);
}
public NeuralNetwork
(AdjacencyGraph <INeuron, Connection> network,
ICollection <INeuron> inputNeurons,
ICollection <INeuron> outputNeurons)
{
_network = network;
_outputNeurons = outputNeurons;
_inputNeurons = inputNeurons;
AlphaVertex = new EmptyNeuron("Alpha");
_network.AddVertex(AlphaVertex);
foreach (var inputNeuron in _inputNeurons)
{
_network.AddEdge(new Connection(AlphaVertex, inputNeuron, 0d));
}
OmegaVertex = new EmptyNeuron("Omega");
_network.AddVertex(OmegaVertex);
foreach (var outputNeuron in _outputNeurons)
{
_network.AddEdge(new Connection(outputNeuron, OmegaVertex, 0d));
}
_algorithm = new BreadthFirstSearchAlgorithm <INeuron, Connection>(_network);
_algorithm.ExamineEdge += AddSignal;
_algorithm.SetRootVertex(AlphaVertex);
}
protected virtual void GenerateSpanningTree(CancellationToken cancellationToken)
{
SpanningTree = new BidirectionalGraph <TVertex, Edge <TVertex> >(false);
SpanningTree.AddVertexRange(VisitedGraph.Vertices.OrderBy(v => VisitedGraph.InDegree(v)));
EdgeAction <TVertex, TEdge> action = e =>
{
cancellationToken.ThrowIfCancellationRequested();
SpanningTree.AddEdge(new Edge <TVertex>(e.Source, e.Target));
};
switch (Parameters.SpanningTreeGeneration)
{
case SpanningTreeGeneration.BFS:
var bfsAlgo = new BreadthFirstSearchAlgorithm <TVertex, TEdge>(VisitedGraph);
bfsAlgo.TreeEdge += action;
bfsAlgo.Compute();
break;
case SpanningTreeGeneration.DFS:
var dfsAlgo = new DepthFirstSearchAlgorithm <TVertex, TEdge>(VisitedGraph);
dfsAlgo.TreeEdge += action;
dfsAlgo.ForwardOrCrossEdge += action;
dfsAlgo.Compute();
break;
}
}
public void NonTreeEdge(Object sender, EdgeEventArgs args)
{
Assert.IsTrue(sender is BreadthFirstSearchAlgorithm);
BreadthFirstSearchAlgorithm algo = (BreadthFirstSearchAlgorithm)sender;
IVertex u = args.Edge.Source;
IVertex v = args.Edge.Target;
Assert.IsFalse(algo.Colors[v] == GraphColor.White);
if (algo.VisitedGraph.IsDirected)
{
// cross or back edge
Assert.IsTrue(Distances[v] <= Distances[u] + 1);
}
else
{
// cross edge (or going backwards on a tree edge)
Assert.IsTrue(
Distances[v] == Distances[u] ||
Distances[v] == Distances[u] + 1 ||
Distances[v] == Distances[u] - 1
);
}
}
public void GrayTarget(Object sender, EdgeEventArgs args)
{
Assert.IsTrue(sender is BreadthFirstSearchAlgorithm);
BreadthFirstSearchAlgorithm algo = (BreadthFirstSearchAlgorithm)sender;
Assert.AreEqual(algo.Colors[args.Edge.Target], GraphColor.Gray);
}
public void FinishVertex(Object sender, VertexEventArgs args)
{
Assert.IsTrue(sender is BreadthFirstSearchAlgorithm);
BreadthFirstSearchAlgorithm algo = (BreadthFirstSearchAlgorithm)sender;
Assert.AreEqual(algo.Colors[args.Vertex], GraphColor.Black);
}
protected override void InternalCompute()
{
this.bfs = new BreadthFirstSearchAlgorithm <TVertex, TEdge>(this.VisitedGraph);
this.observer = new VertexPredecessorRecorderObserver <TVertex, TEdge>();
try
{
this.observer.Attach(this.bfs);
this.bfs.DiscoverVertex += new VertexEventHandler <TVertex>(bfs_DiscoverVertex);
bfs.Compute();
this.OnIterationEnded(EventArgs.Empty);
}
finally
{
if (this.observer != null)
{
this.observer.Detach(this.bfs);
this.observer = null;
}
if (this.bfs != null)
{
this.bfs.DiscoverVertex -= new VertexEventHandler <TVertex>(bfs_DiscoverVertex);
this.bfs = null;
}
}
}
public void Walk()
{
var breadthFirstSearchAlgorithm = new BreadthFirstSearchAlgorithm <string, ToscaGraphEdge>(graph);
breadthFirstSearchAlgorithm.DiscoverVertex += nodeTypeName => { action(nodeTypeName, nodeTypes[nodeTypeName]); };
breadthFirstSearchAlgorithm.Compute(ToscaDefaults.ToscaNodesRoot);
}
public static double MeasureBFSQuickGraphSpeed(string path)
{
AdjacencyGraph <int, Edge <int> > graph = Util.ReadMatrixMarketFileToQuickGraph(path);
var algo = new BreadthFirstSearchAlgorithm <int, Edge <int> >(graph);
return(MeasureQuickGraphAlgorithmSpeed(algo));
}
static void Main(string[] args)
{
//Read file
Console.WriteLine("Please provide a file name:");
var fileName = Console.ReadLine();
if (String.IsNullOrEmpty(fileName))
{
Console.WriteLine("Please provide a file name.");
return;
}
if (!File.Exists(fileName))
{
Console.WriteLine($"File {fileName} is not found.");
Console.ReadKey();
return;
}
//Get log file name
Console.WriteLine("Please provide a output file name:");
var outputFileName = Console.ReadLine();
if (String.IsNullOrEmpty(outputFileName))
{
Console.WriteLine("Please provide a file name.");
return;
}
//Collect input data
var text = File.ReadAllText(fileName);
var lines = text.Split(new[] { Environment.NewLine }, StringSplitOptions.None);
var height = lines.Count() - 1;
var width = lines[0].Split(' ').Count();
var labyrinth = new int[height, width];
for (int i = 0; i < height; i++)
{
var line = lines[i].Split(' ');
for (int j = 0; j < line.Length; j++)
{
labyrinth[i, j] = int.Parse(line[j]);
}
}
var startCoordinates = lines.Last().Split(' ');
var x = int.Parse(startCoordinates[0]);
var y = int.Parse(startCoordinates[1]);
//Execute algorithm
//using (var algorithm = new DepthFirstSearchAlgorithm(labyrinth, y - 1, x - 1, new FileLoggerService(outputFileName)))
using (var algorithm = new BreadthFirstSearchAlgorithm(labyrinth, y - 1, x - 1, new FileLoggerService(outputFileName)))
{
algorithm.Execute();
Console.WriteLine("Press any key to exit.");
Console.ReadKey();
}
}
/// <summary>
/// Computes the maximum flow between Source and Sink.
/// </summary>
/// <returns></returns>
protected override void InternalCompute()
{
if (this.Source == null)
{
throw new InvalidOperationException("Source is not specified");
}
if (this.Sink == null)
{
throw new InvalidOperationException("Sink is not specified");
}
if (this.Services.CancelManager.IsCancelling)
{
return;
}
var g = this.VisitedGraph;
foreach (var u in g.Vertices)
{
foreach (var e in g.OutEdges(u))
{
var capacity = this.Capacities(e);
if (capacity < 0)
{
throw new InvalidOperationException("negative edge capacity");
}
this.ResidualCapacities[e] = capacity;
}
}
this.VertexColors[Sink] = GraphColor.Gray;
while (this.VertexColors[Sink] != GraphColor.White)
{
var vis = new VertexPredecessorRecorderObserver <TVertex, TEdge>(
this.Predecessors
);
var queue = new QuickGraph.Collections.Queue <TVertex>();
var bfs = new BreadthFirstSearchAlgorithm <TVertex, TEdge>(
this.ResidualGraph,
queue,
this.VertexColors
);
using (vis.Attach(bfs))
bfs.Compute(this.Source);
if (this.VertexColors[this.Sink] != GraphColor.White)
{
this.Augment(this.Source, this.Sink);
}
} // while
this.MaxFlow = 0;
foreach (var e in g.OutEdges(Source))
{
this.MaxFlow += (this.Capacities(e) - this.ResidualCapacities[e]);
}
}
public void Walk(string nodeTypeNameToStart, Action <string, ToscaNodeType> action)
{
var breadthFirstSearchAlgorithm = new BreadthFirstSearchAlgorithm <string, ToscaGraphEdge>(graph);
breadthFirstSearchAlgorithm.DiscoverVertex +=
nodeTypeName => { action(nodeTypeName, nodeTypes[nodeTypeName]); };
breadthFirstSearchAlgorithm.Compute(nodeTypeNameToStart);
}
public void ComputeWithRoot()
{
var graph = new AdjacencyGraph <int, Edge <int> >();
graph.AddVertex(0);
var algorithm = new BreadthFirstSearchAlgorithm <int, Edge <int> >(graph);
ComputeWithRoot_Test(algorithm);
}
private void RemoveIrrelevantBranches(AdjacencyGraph <IBuilder, EquatableEdge <IBuilder> > graph, IBuilder rootBuilder)
{
var bfs = new BreadthFirstSearchAlgorithm <IBuilder, EquatableEdge <IBuilder> >(graph);
bfs.Compute(rootBuilder);
var toKeep = new HashSet <IBuilder>(bfs.VisitedGraph.Vertices);
graph.RemoveVertexIf(v => !toKeep.Contains(v));
}
/// <summary>
/// Computes the maximum flow between Source and Sink.
/// </summary>
protected override void InternalCompute()
{
if (Source == null)
{
throw new InvalidOperationException("Source is not specified.");
}
if (Sink == null)
{
throw new InvalidOperationException("Sink is not specified.");
}
if (Services.CancelManager.IsCancelling)
{
return;
}
var graph = VisitedGraph;
foreach (TVertex vertex in graph.Vertices)
{
foreach (TEdge edge in graph.OutEdges(vertex))
{
double capacity = Capacities(edge);
if (capacity < 0)
{
throw new InvalidOperationException("Negative edge capacity.");
}
ResidualCapacities[edge] = capacity;
}
}
VerticesColors[Sink] = GraphColor.Gray;
while (VerticesColors[Sink] != GraphColor.White)
{
var verticesPredecessors = new VertexPredecessorRecorderObserver <TVertex, TEdge>(Predecessors);
var queue = new Queue <TVertex>();
var bfs = new BreadthFirstSearchAlgorithm <TVertex, TEdge>(
ResidualGraph,
queue,
VerticesColors);
using (verticesPredecessors.Attach(bfs))
bfs.Compute(Source);
if (VerticesColors[Sink] != GraphColor.White)
{
Augment(Source, Sink);
}
}
MaxFlow = 0;
foreach (TEdge edge in graph.OutEdges(Source))
{
MaxFlow += (Capacities(edge) - ResidualCapacities[edge]);
}
}
public void BinarySearch_ValidItem()
{
var person = CreatePerson();
var search = new BreadthFirstSearchAlgorithm();
var result = search.SearchRobot(person);
Assert.NotNull(result);
Assert.Equal("Robot", result);
}
public void BlackTarget(Object sender, EdgeEventArgs args)
{
Assert.IsTrue(sender is BreadthFirstSearchAlgorithm);
BreadthFirstSearchAlgorithm algo = (BreadthFirstSearchAlgorithm)sender;
Assert.AreEqual(algo.Colors[args.Edge.Target], GraphColor.Black);
foreach (IEdge e in algo.VisitedGraph.OutEdges(args.Edge.Target))
{
Assert.IsFalse(algo.Colors[e.Target] == GraphColor.White);
}
}
public NeuralNetwork(AdjacencyGraph <INeuron, Connection> network, INeuron alphaVertex, INeuron omegaVertex)
{
_network = network;
AlphaVertex = alphaVertex;
OmegaVertex = omegaVertex;
_inputNeurons = _network.OutEdges(AlphaVertex).Select(e => e.Target).ToList();
_outputNeurons = _network.Edges.Where(e => e.Target == OmegaVertex).Select(e => e.Source).ToList();
_algorithm = new BreadthFirstSearchAlgorithm <INeuron, Connection>(_network);
_algorithm.ExamineEdge += AddSignal;
_algorithm.SetRootVertex(AlphaVertex);
}
public void TreeEdge(Object sender, EdgeEventArgs args)
{
Assert.IsTrue(sender is BreadthFirstSearchAlgorithm);
BreadthFirstSearchAlgorithm algo = (BreadthFirstSearchAlgorithm)sender;
IVertex u = args.Edge.Source;
IVertex v = args.Edge.Target;
Assert.AreEqual(algo.Colors[v], GraphColor.White);
Assert.AreEqual(Distances[u], CurrentDistance);
Parents[v] = u;
Distances[v] = Distances[u] + 1;
}
private void RemoveIrrelevantBranches(AdjacencyGraph <IBuilder, EquatableEdge <IBuilder> > graph, IBuilder rootBuilder)
{
var bfs = new BreadthFirstSearchAlgorithm <IBuilder, EquatableEdge <IBuilder> >(graph);
var toKeep = new HashSet <EquatableEdge <IBuilder> >();
var buildersToKeep = new HashSet <IBuilder>();
bfs.TreeEdge += e => toKeep.Add(e);
bfs.NonTreeEdge += e => toKeep.Add(e);
bfs.DiscoverVertex += b => buildersToKeep.Add(b);
bfs.Compute(rootBuilder);
graph.RemoveEdgeIf(edge => !toKeep.Contains(edge));
graph.RemoveVertexIf(vertex => !buildersToKeep.Contains(vertex));
}
private void breadthFirstSearchItem_Click(object sender, System.EventArgs e)
{
if (this.netronPanel.Graph == null)
{
throw new Exception("Generate a graph first");
}
if (this.netronPanel.Populator == null)
{
throw new Exception("Populator should not be null.");
}
ResetVertexAndEdgeColors();
// create algorithm
this.edgeColors = new EdgeColorDictionary();
foreach (IEdge edge in this.netronPanel.Graph.Edges)
{
this.edgeColors[edge] = GraphColor.White;
}
this.vertexColors = new VertexColorDictionary();
BreadthFirstSearchAlgorithm bfs = new BreadthFirstSearchAlgorithm(
this.netronPanel.Graph,
new VertexBuffer(),
this.vertexColors);
// create tracer
LayoutAlgorithmTraverVisitor tracer = new LayoutAlgorithmTraverVisitor(this.netronPanel.Populator);
// link to algo
bfs.RegisterTreeEdgeBuilderHandlers(tracer);
bfs.RegisterVertexColorizerHandlers(tracer);
bfs.TreeEdge += new EdgeEventHandler(dfs_TreeEdge);
bfs.NonTreeEdge += new EdgeEventHandler(dfs_BackEdge);
bfs.BlackTarget += new EdgeEventHandler(dfs_ForwardOrCrossEdge);
// add handler to tracers
tracer.UpdateVertex += new ShapeVertexEventHandler(tracer_UpdateVertex);
tracer.UpdateEdge += new ConnectionEdgeEventHandler(tracer_UpdateEdge);
// running algorithm
VertexMethodCaller vm =
new VertexMethodCaller(
new ComputeVertexDelegate(bfs.Compute),
Traversal.FirstVertex(this.netronPanel.Graph)
);
Thread thread = new Thread(new ThreadStart(vm.Run));
thread.Start();
}
public void Test2()
{
string chosenMap = @"
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 D 0 0 0 0 0 0 0 0 0 0 0 0 S 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
";
var map = new Map(chosenMap);
var algorithm = new BreadthFirstSearchAlgorithm(map.StartX, map.StartY, map.DestX, map.DestY, chosenMap);
var sw = System.Diagnostics.Stopwatch.StartNew();
var result = algorithm.run();
sw.Stop();
Assert.IsTrue(sw.ElapsedMilliseconds < 100);
System.Diagnostics.Debug.WriteLine("Elapsed: " + sw.ElapsedMilliseconds);
result.Paths[0].NodeEquals(4, 10);
result.Paths[1].NodeEquals(5, 10);
result.Paths[2].NodeEquals(6, 10);
result.Paths[3].NodeEquals(7, 10);
result.Paths[4].NodeEquals(8, 10);
result.Paths[5].NodeEquals(9, 10);
result.Paths[6].NodeEquals(10, 10);
result.Paths[7].NodeEquals(11, 10);
result.Paths[8].NodeEquals(12, 10);
result.Paths[9].NodeEquals(13, 10);
result.Paths[10].NodeEquals(14, 10);
result.Paths[11].NodeEquals(15, 10);
result.Paths[12].NodeEquals(16, 10);
result.Paths[13].NodeEquals(17, 10);
}
/// <summary>
/// Computes the maximum flow between <paramref name="src"/> and
/// <paramref name="sink"/>
/// </summary>
/// <param name="src"></param>
/// <param name="sink"></param>
/// <returns></returns>
public override double Compute(IVertex src, IVertex sink)
{
if (src == null)
{
throw new ArgumentNullException("src");
}
if (sink == null)
{
throw new ArgumentNullException("sink");
}
foreach (IVertex u in VisitedGraph.Vertices)
{
foreach (IEdge e in VisitedGraph.OutEdges(u))
{
ResidualCapacities[e] = Capacities[e];
}
}
Colors[sink] = GraphColor.Gray;
while (Colors[sink] != GraphColor.White)
{
PredecessorRecorderVisitor vis = new PredecessorRecorderVisitor(
Predecessors
);
VertexBuffer Q = new VertexBuffer();
BreadthFirstSearchAlgorithm bfs = new BreadthFirstSearchAlgorithm(
ResidualGraph,
Q,
Colors
);
bfs.RegisterPredecessorRecorderHandlers(vis);
bfs.Compute(src);
if (Colors[sink] != GraphColor.White)
{
Augment(src, sink);
}
} // while
double flow = 0;
foreach (IEdge e in VisitedGraph.OutEdges(src))
{
flow += (Capacities[e] - ResidualCapacities[e]);
}
return(flow);
}
