public static long getMaxFlow(this MyGraph myGraph)
{
long totalFlow;
var pipes = myGraph.Pipes;
var nodes = myGraph.Nodes;
int numNodes = nodes.Count();
int numPipes = pipes.Count();
char startingPoint = Char.Parse(myGraph.getStartingPoint());
char endPoint = Char.Parse(myGraph.getEndPoint());
List <int> tails, heads, capacities;
tails = new List <int>();
heads = new List <int>();
capacities = new List <int>();
foreach (var node in nodes)
{
foreach (var pipe in node.Pipes)
{
if (pipe.StartingValue > 0)
{
tails.Add(Char.Parse(pipe.StartingPoint) - 'A');
heads.Add(Char.Parse(pipe.EndPoint) - 'A');
capacities.Add(pipe.StartingValue);
}
}
}
MaxFlow maxFlow = new MaxFlow();
for (int i = 0; i < tails.Count(); ++i)
{
int arc = maxFlow.AddArcWithCapacity(tails[i], heads[i], capacities[i]);
if (arc != i)
{
throw new Exception("Internal error");
}
}
int source = startingPoint - 'A';
int sink = endPoint - 'A';
Console.WriteLine("Solving max flow with " + numNodes + " nodes, and " +
numPipes + " arcs, source=" + source + ", sink=" + sink);
MaxFlow.Status solveStatus = maxFlow.Solve(source, sink);
if (solveStatus == MaxFlow.Status.OPTIMAL)
{
totalFlow = maxFlow.OptimalFlow();
}
else
{
Console.WriteLine("Solving the max flow problem failed. Solver status: " +
solveStatus);
totalFlow = 0;
}
return(totalFlow);
}
static void Main()
{
// [START data]
// Define three parallel arrays: start_nodes, end_nodes, and the capacities
// between each pair. For instance, the arc from node 0 to node 1 has a
// capacity of 20.
// From Taha's 'Introduction to Operations Research',
// example 6.4-2.
int[] startNodes = { 0, 0, 0, 1, 1, 2, 2, 3, 3 };
int[] endNodes = { 1, 2, 3, 2, 4, 3, 4, 2, 4 };
int[] capacities = { 20, 30, 10, 40, 30, 10, 20, 5, 20 };
// [END data]
// [START constraints]
// Instantiate a SimpleMaxFlow solver.
MaxFlow maxFlow = new MaxFlow();
// Add each arc.
for (int i = 0; i < startNodes.Length; ++i)
{
int arc = maxFlow.AddArcWithCapacity(startNodes[i], endNodes[i],
capacities[i]);
if (arc != i)
{
throw new Exception("Internal error");
}
}
// [END constraints]
// [START solve]
// Find the maximum flow between node 0 and node 4.
MaxFlow.Status solveStatus = maxFlow.Solve(0, 4);
// [END solve]
// [START print_solution]
if (solveStatus == MaxFlow.Status.OPTIMAL)
{
Console.WriteLine("Max. flow: " + maxFlow.OptimalFlow());
Console.WriteLine("");
Console.WriteLine(" Arc Flow / Capacity");
for (int i = 0; i < maxFlow.NumArcs(); ++i)
{
Console.WriteLine(maxFlow.Tail(i) + " -> " +
maxFlow.Head(i) + " " +
string.Format("{0,3}", maxFlow.Flow(i)) + " / " +
string.Format("{0,3}", maxFlow.Capacity(i)));
}
}
else
{
Console.WriteLine("Solving the max flow problem failed. Solver status: " +
solveStatus);
}
// [END print_solution]
}
private static void SolveMaxFlow()
{
Console.WriteLine("Max Flow Problem");
int numNodes = 6;
int numArcs = 9;
int[] tails = { 0, 0, 0, 0, 1, 2, 3, 3, 4 };
int[] heads = { 1, 2, 3, 4, 3, 4, 4, 5, 5 };
int[] capacities = { 5, 8, 5, 3, 4, 5, 6, 6, 4 };
int[] expectedFlows = { 4, 4, 2, 0, 4, 4, 0, 6, 4 };
int expectedTotalFlow = 10;
MaxFlow maxFlow = new MaxFlow();
for (int i = 0; i < numArcs; ++i)
{
int arc = maxFlow.AddArcWithCapacity(tails[i], heads[i], capacities[i]);
if (arc != i)
{
throw new Exception("Internal error");
}
}
int source = 0;
int sink = numNodes - 1;
Console.WriteLine("Solving max flow with " + numNodes + " nodes, and " +
numArcs + " arcs, source=" + source + ", sink=" + sink);
MaxFlow.Status solveStatus = maxFlow.Solve(source, sink);
if (solveStatus == MaxFlow.Status.OPTIMAL)
{
long totalFlow = maxFlow.OptimalFlow();
Console.WriteLine("total computed flow " + totalFlow +
", expected = " + expectedTotalFlow);
for (int i = 0; i < numArcs; ++i)
{
Console.WriteLine("Arc " + i + " (" + maxFlow.Head(i) + " -> " +
maxFlow.Tail(i) + "), capacity = " +
maxFlow.Capacity(i) + ") computed = " +
maxFlow.Flow(i) + ", expected = " + expectedFlows[i]);
}
}
else
{
Console.WriteLine("Solving the max flow problem failed. Solver status: " +
solveStatus);
}
}
