Tarjan's strongly connected component and Shortest Cycle finder algorithm

lib/Fhaculty/Graph/Algorithm/CycleFinder.php

@@ -0,0 +1,57 @@
+<?php
+
+namespace Fhaculty\Graph\Algorithm;
+
+use Fhaculty\Graph\Algorithm\ShortestPath\Dijkstra;
+use Fhaculty\Graph\Algorithm\StronglyConnectedComponents\Tarjan;
+use Fhaculty\Graph\Walk;
+use Fhaculty\Graph\Graph;
+
+class CycleFinder extends BaseGraph
+{
+    /**
+     * @see (not used) http://stones333.blogspot.fr/2013/12/find-cycles-in-directed-graph-dag.html
+     * @see http://stackoverflow.com/questions/10456935/graph-how-to-find-minimum-directed-cycle-minimum-total-weight
+     */
+    public function getShortestCycle()
+    {
+        $walkMap = array();
+        $vertices = $this->graph->getVertices()->getList();
+
+        // Compute distance map
+        foreach($vertices as $u){
+            foreach($vertices as $v){
+                if($u === $v){
+                    continue;
+                }
+                if(isset($walkMap[$u->getId()][$v->getId()])){
+                    continue;
+                }
+                $distUV = new Dijkstra($u);
+                $walkMap[$u->getId()][$v->getId()] = $distUV->getWalkTo($v);
+            }
+        }
+
+        // The eulerian path is the shortest
+        $minimum = count($this->graph->getEdges()) + 1;
+        $walk = null;
+
+        // Find shortest
+        foreach($vertices as $u){
+            foreach($vertices as $v){
+                if($u === $v){
+                    continue;
+                }
+                $walkU = $walkMap[$u->getId()][$v->getId()];
+                $walkV = $walkMap[$v->getId()][$u->getId()];
+                $length = $walkU->getLength() + $walkV->getLength();
+                if($length < $minimum){
+                    $minimum = $length;
+                    $walk = $walkU->append($walkV);
+                }
+            }
+        }
+
+        return $walk;
+    }
+} 

lib/Fhaculty/Graph/Algorithm/StronglyConnectedComponents/Tarjan.php

@@ -0,0 +1,100 @@
+<?php
+
+namespace Fhaculty\Graph\Algorithm\StronglyConnectedComponents;
+
+use Fhaculty\Graph\Algorithm\BaseGraph;
+use Fhaculty\Graph\Algorithm\Directed;
+use Fhaculty\Graph\Exception\InvalidArgumentException;
+use Fhaculty\Graph\Graph;
+use Fhaculty\Graph\Set\Vertices;
+use Fhaculty\Graph\Vertex;
+use Fhaculty\Graph\Set\VerticeDataMap;
+
+/**
+ * @see http://github.com/Trismegiste/Mondrian/blob/master/Graph/Tarjan.php
+ */
+class Tarjan extends BaseGraph
+{
+    private $stack;
+    private $index;
+    private $partition;
+
+    private $indexMap = array();
+    private $lowLinkMap = array();
+
+    /**
+     * @param Graph $graph
+     */
+    public function __construct(Graph $graph)
+    {
+        parent::__construct($graph);
+        $this->indexMap = new VerticeDataMap();
+        $this->lowLinkMap = new VerticeDataMap();
+    }
+
+    /**
+     * Get the strongly connected components of this digraph by
+     * the Tarjan algorithm.
+     *
+     * Starting from :
+     * http://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm
+     *
+     * Corrected with the help :
+     * https://code.google.com/p/jbpt/source/browse/trunk/jbpt-core/src/main/java/org/jbpt/algo/graph/StronglyConnectedComponents.java
+     * @throws \Fhaculty\Graph\Exception\InvalidArgumentException
+     * @return array the partition of this graph : an array of an array of vertices
+     */
+    public function getStronglyConnected()
+    {
+
+        // check is directed
+        $directed = new Directed($this->graph);
+        if($directed->hasUndirected()){
+            throw new InvalidArgumentException('Graph shall be directed');
+        }
+
+        $this->stack = array();
+        $this->index = 0;
+        $this->partition = array();
+
+        foreach ($this->graph->getVertices()->getList() as $vertex) {
+            if (! isset($this->indexMap[$vertex])) {
+                $this->recursivStrongConnect($vertex);
+            }
+        }
+
+        return $this->partition;
+    }
+
+    private function recursivStrongConnect(Vertex $v)
+    {
+        $this->indexMap[$v] = $this->index;
+        $this->lowLinkMap[$v] = $this->index;
+        $this->index++;
+        array_push($this->stack, $v);
+
+        // Consider successors of v
+        foreach ($v->getVerticesEdgeTo() as $w) {
+            if (! isset($this->indexMap[$w]) ) {
+                // Successor w has not yet been visited; recurse on it
+                $this->recursivStrongConnect($w);
+                $this->lowLinkMap[$v] = min(array($this->lowLinkMap[$v], $this->lowLinkMap[$w]));
+            } elseif (in_array($w, $this->stack)) {
+                // Successor w is in stack S and hence in the current SCC
+                $this->lowLinkMap[$v] = min(array($this->lowLinkMap[$v], $this->indexMap[$w]));
+            }
+        }
+        // If v is a root node, pop the stack and generate an SCC
+        if ($this->lowLinkMap[$v] === $this->indexMap[$v]) {
+            $scc = array();
+            do {
+                $w = array_pop($this->stack);
+                array_push($scc, $w);
+            } while ($w !== $v);
+
+            if (count($scc)) {
+                $this->partition[] = new Vertices($scc);
+            }
+        }
+    }
+} 

lib/Fhaculty/Graph/Edge/Base.php

@@ -250,9 +250,9 @@ public function getGraph()
      */
     public function destroy()
     {
-        $this->getGraph()->removeEdge($this);
+        $this->getGraph()->removeEdge($this, false);
         foreach ($this->getVertices() as $vertex) {
-            $vertex->removeEdge($this);
+            $vertex->removeEdge($this, false);
         }
     }
 

lib/Fhaculty/Graph/Graph.php

@@ -362,14 +362,18 @@ public function addEdge(Edge $edge)
      * @private
      * @see Edge::destroy() instead!
      */
-    public function removeEdge(Edge $edge)
+    public function removeEdge(Edge $edge, $throwException = true)
     {
-        try {
-            unset($this->edgesStorage[$this->edges->getIndexEdge($edge)]);
+        $id = $this->edges->getIndexEdge($edge);
+        if ($id === false) {
+            if($throwException){
+                throw new InvalidArgumentException('Invalid Edge does not exist in this Graph');
+            }
         }
-        catch (OutOfBoundsException $e) {
-            throw new InvalidArgumentException('Invalid Edge does not exist in this Graph');
+        else{
+            unset($this->edgesStorage[$id]);
         }
+
     }
 
     /**

lib/Fhaculty/Graph/Set/Edges.php

@@ -117,16 +117,11 @@ public function __construct(array $edges = array())
      * get array index for given Edge
      *
      * @param Edge $edge
-     * @throws OutOfBoundsException
      * @return mixed
      */
     public function getIndexEdge(Edge $edge)
     {
-        $id = array_search($edge, $this->edges, true);
-        if ($id === false) {
-            throw new OutOfBoundsException('Given edge does NOT exist');
-        }
-        return $id;
+        return array_search($edge, $this->edges, true);
     }
 
     /**

lib/Fhaculty/Graph/Set/VerticeDataMap.php

@@ -0,0 +1,43 @@
+<?php
+
+
+namespace Fhaculty\Graph\Set;
+
+class VerticeDataMap implements \ArrayAccess
+{
+    private $dataMap = array();
+
+    /**
+     * {@inheritdoc}
+     */
+    public function offsetExists($offset)
+    {
+        return isset($this->dataMap[$offset->getId()]);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function offsetGet($offset)
+    {
+        return $this->dataMap[$offset->getId()];
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function offsetSet($offset, $value)
+    {
+        $this->dataMap[$offset->getId()] = $value;
+        return $this;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function offsetUnset($offset)
+    {
+        unset($this->dataMap[$offset->getId()]);
+    }
+
+} 

lib/Fhaculty/Graph/Set/VerticesMap.php

@@ -16,6 +16,11 @@
  */
 class VerticesMap extends Vertices
 {
+    public function getList()
+    {
+        return array_values($this->getMap());
+    }
+
     public function getMap()
     {
         return $this->vertices;

lib/Fhaculty/Graph/Vertex.php

@@ -171,13 +171,17 @@ public function addEdge(Edge $edge)
      * @private
      * @see Edge::destroy() instead!
      */
-    public function removeEdge(Edge $edge)
+    public function removeEdge(Edge $edge, $throwException = true)
     {
         $id = array_search($edge, $this->edges, true);
         if ($id === false) {
-            throw new InvalidArgumentException('Given edge does NOT exist');
+            if($throwException){
+                throw new InvalidArgumentException('Given edge does NOT exist');
+            }
+        }
+        else{
+            unset($this->edges[$id]);
         }
-        unset($this->edges[$id]);
     }
 
     /**

lib/Fhaculty/Graph/Walk.php

@@ -310,4 +310,42 @@ public function isValid()
 
         return true;
     }
+
+    public function getLength()
+    {
+        return count($this->getEdges());
+    }
+
+    public function __toString()
+    {
+        $ret = array();
+        foreach($this->getEdges() as $e){
+            array_push($ret, sprintf('%s -> %s',
+                $e->getVertexStart()->getId(),
+                $e->getVertexEnd()->getId()
+            ));
+        }
+        return implode(', ', $ret);
+    }
+
+    /**
+     * @param Walk $walk
+     */
+    public function append(Walk $walk)
+    {
+        // first edge need to be starting at the same point.
+        if(
+            $this->getVertices()->getVertexFirst() !==
+            $walk->getVertices()->getVertexLast()
+        ) {
+            throw new InvalidArgumentException('First vertex of $walk shall be the same as the last one');
+        }
+
+        $vertices = array_merge(
+            $this->getVertices()->getVector(),
+            array_slice($walk->getVertices()->getVector(), 1)
+        );
+
+        return self::factoryCycleFromVertices($vertices);
+    }
 }

tests/Fhaculty/Graph/Algorithm/CycleFinderTest.php

@@ -0,0 +1,35 @@
+<?php
+
+use Fhaculty\Graph\Graph;
+
+use Fhaculty\Graph\Algorithm\CycleFinder;
+use Fhaculty\Graph\Algorithm\StronglyConnectedComponents\Tarjan;
+use Fhaculty\Graph\Walk;
+
+class CycleFinderTest extends TestCase
+{
+    public function testGraphHaSCycle()
+    {
+        $graph = new Graph();
+
+        $A = $graph->createVertex("A");
+        $B = $graph->createVertex("B");
+        $C = $graph->createVertex("C");
+
+        $A->createEdgeTo($B);
+        $B->createEdgeTo($C);
+        $C->createEdgeTo($A);
+        $B->createEdgeTo($A);
+
+        // $tarjan = new Tarjan($graph);
+        // $componentsVertices = $tarjan->getStronglyConnected();
+        // foreach($componentsVertices as $componentVertices){
+        // $component = $graph->createGraphCloneVertices($componentVertices);
+
+        $find = new CycleFinder($graph);
+        $shortest = $find->getShortestCycle();
+
+        $walk = Walk::factoryCycleFromVertices(array($A, $B, $A));
+        $this->assertSame($walk->__toString(), $shortest->__toString());
+    }
+}