예제 #1
0
 /**
  * Use this method to build the graph. It will add an edge to the graph and
  * also its nodes, if necessary. The node identifiers can be any object. Two
  * objects identify the same node, if they are equal according to their
  * equals function.
  * 
  * @param startNodeID
  *            Identifier object of the start node of the edge
  * @param endNodeID
  *            Identifier object of the end node of the edge
  * @param capacity
  *            Capacity of the edge
  */
 public void addEdge(Object startNodeID, Object endNodeID, int capacity)
 {
     Node startNode;
     Node endNode;
     if (!this.nodes.ContainsKey(startNodeID))
     {
         startNode = new Node();
         this.nodes.Add(startNodeID, startNode);
     }
     else
     {
         startNode = this.nodes[startNodeID];
     }
     if (!this.nodes.ContainsKey(endNodeID))
     {
         endNode = new Node();
         this.nodes.Add(endNodeID, endNode);
     }
     else
     {
         endNode = this.nodes[endNodeID];
     }
     EdgeF edge = new EdgeF(startNodeID, endNodeID, capacity);
     startNode.addEdge(edge);
     endNode.addEdge(edge);
     this.edges.AddLast(edge);
 }
예제 #2
0
        /**
         * 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);
        }
예제 #3
0
 public void addEdge(EdgeF edge)
 {
     this.edges.Add(edge);
 }