/**
* This method gives the actual flow value by adding all flow values of the
* out leading edges of the source.
*
* @param flow A HashMap of the form like getMaxFlow produces them
* @param g The directed Graph
* @param source The object identifying the source node of the flow
* @return The value of the given flow
*/
// 10
public int getFlowSize(Dictionary <EdgeF, int> flow, DirectedGraph g,
Object source)
{
//-------------------
int maximumFlow = 0; af++; ffLines++;
Node sourceNode = g.getNode(source); af++; ffLines++;
//-------------------
compF++; af++;
ffLines++;
for (int i = 0; i < sourceNode.getOutLeadingOrder(); i++)
{
ffLines += 2;
compF++;
maximumFlow += flow[sourceNode.getEdge(i)]; af++; ffLines++;
}
ffLines++;
return(maximumFlow);
//-------------------
}
/**
* Simple breadth first search in the directed graph
*
* @param g The directed Graph
* @param start The object that identifying the start node of the search
* @param target The object that identifying the target node of the search
* @param flow A HashMap of the form like getMaxFlow produces them. If an
* edge has a value > 0 in it, it will also be used in the opposite
* direction. Also edges that have a value equal to its capacity will be
* ignored.
* @return A list of all edges of the found path in the order in which they
* are used, null if there is no path. If the start node equals the target
* node, an empty list is returned.
*/
public LinkedList <EdgeF> bfs(DirectedGraph g, Object start, Object target,
Dictionary <EdgeF, int> flow)
{
//-------------------
// The edge by which a node was reached.
Dictionary <Object, EdgeF> parent = new Dictionary <Object, EdgeF>(); af++; ffLines++;
// All outer nodes of the current search iteration.
LinkedList <Object> fringe = new LinkedList <Object>(); af++; ffLines++;
//-------------------
// We need to put the start node into those two.
parent.Add(start, null); af++; ffLines++;
fringe.AddLast(start); af++; ffLines++;
// The actual algorithm
bool stop = false; af++; ffLines++;
//-------------------
compF++; ffLines++;
while (!fringe.Count.Equals(0))
{
ffLines++;
compF++;
// This variable is needed to prevent the JVM from having a
// concurrent modification
//-------------------
LinkedList <Object> newFringe = new LinkedList <Object>(); af++; ffLines++;
//-------------------
// Iterate through all nodes in the fringe.
compF++;
ffLines++;
foreach (Object nodeID in fringe)
{
ffLines++;
compF++;
Node nodes = g.getNode(nodeID); af++; ffLines++;
// Iterate through all the edges of the node.
compF++; af++; ffLines++;
for (int i = 0; i < nodes.getOutLeadingOrder(); i++)
{
compF++; af++; ffLines++;
EdgeF e = nodes.getEdge(i); af++; ffLines++;
//-------------------
// Only add the node if the flow can be changed in an out
// leading direction. Also break, if the target is reached.
//-------------------
compF += 3; ffLines += 3;
if (e.getStart().Equals(nodeID) &&
!parent.ContainsKey(e.getTarget()) &&
flow[e] < e.getCapacity())
{
parent.Add(e.getTarget(), e); af++; ffLines++;
compF++; ffLines++;
if (e.getTarget().Equals(target))
{
stop = true; af++; ffLines++;
break;
}
newFringe.AddLast(e.getTarget()); af++; ffLines++;
}
else if (e.getTarget().Equals(nodeID) &&
!parent.ContainsKey(e.getStart()) &&
flow[e] > 0)
{
ffLines++;
parent.Add(e.getStart(), e); af++; ffLines++;
compF++;
ffLines++;
if (e.getStart().Equals(target))
{
stop = true; af++; ffLines++;
break;
}
newFringe.AddLast(e.getStart()); af++; ffLines++;
}
ffLines++;
compF += 3;
}
ffLines++;
compF++;
if (stop)
{
break;
}
}
compF++; ffLines++;
if (stop)
{
break;
}
// Replace the fringe by the new one.
fringe = newFringe; af++; ffLines++;
}
// Return null, if no path was found.
compF++; ffLines++;
if (fringe.Count.Equals(0))
{
return(null);
}
// If a path was found, reconstruct it.
Object node = target; af++; ffLines++;
LinkedList <EdgeF> path = new LinkedList <EdgeF>(); af++; ffLines++;
compF++;
ffLines++;
while (!node.Equals(start))
{
ffLines++;
compF++;
EdgeF e = parent[node]; af++; ffLines++;
path.AddFirst(e); af++; ffLines++;
compF++;
ffLines++;
if (e.getStart().Equals(node))
{
node = e.getTarget(); af++; ffLines++;
}
else
{
ffLines++;
node = e.getStart(); af++; ffLines++;
}
}
ffLines++;
// Return the path.
return(path);
}