Finding all cycles in a directed graph

前端 未结 17 2169
渐次进展
渐次进展 2020-11-22 05:47

How can I find (iterate over) ALL the cycles in a directed graph from/to a given node?

For example, I want something like this:

A->B->A
A->B         


        
相关标签:
17条回答
  • 2020-11-22 06:21

    If what you want is to find all elementary circuits in a graph you can use the EC algorithm, by JAMES C. TIERNAN, found on a paper since 1970.

    The very original EC algorithm as I managed to implement it in php (hope there are no mistakes is shown below). It can find loops too if there are any. The circuits in this implementation (that tries to clone the original) are the non zero elements. Zero here stands for non-existence (null as we know it).

    Apart from that below follows an other implementation that gives the algorithm more independece, this means the nodes can start from anywhere even from negative numbers, e.g -4,-3,-2,.. etc.

    In both cases it is required that the nodes are sequential.

    You might need to study the original paper, James C. Tiernan Elementary Circuit Algorithm

    <?php
    echo  "<pre><br><br>";
    
    $G = array(
            1=>array(1,2,3),
            2=>array(1,2,3),
            3=>array(1,2,3)
    );
    
    
    define('N',key(array_slice($G, -1, 1, true)));
    $P = array(1=>0,2=>0,3=>0,4=>0,5=>0);
    $H = array(1=>$P, 2=>$P, 3=>$P, 4=>$P, 5=>$P );
    $k = 1;
    $P[$k] = key($G);
    $Circ = array();
    
    
    #[Path Extension]
    EC2_Path_Extension:
    foreach($G[$P[$k]] as $j => $child ){
        if( $child>$P[1] and in_array($child, $P)===false and in_array($child, $H[$P[$k]])===false ){
        $k++;
        $P[$k] = $child;
        goto EC2_Path_Extension;
    }   }
    
    #[EC3 Circuit Confirmation]
    if( in_array($P[1], $G[$P[$k]])===true ){//if PATH[1] is not child of PATH[current] then don't have a cycle
        $Circ[] = $P;
    }
    
    #[EC4 Vertex Closure]
    if($k===1){
        goto EC5_Advance_Initial_Vertex;
    }
    //afou den ksana theoreitai einai asfales na svisoume
    for( $m=1; $m<=N; $m++){//H[P[k], m] <- O, m = 1, 2, . . . , N
        if( $H[$P[$k-1]][$m]===0 ){
            $H[$P[$k-1]][$m]=$P[$k];
            break(1);
        }
    }
    for( $m=1; $m<=N; $m++ ){//H[P[k], m] <- O, m = 1, 2, . . . , N
        $H[$P[$k]][$m]=0;
    }
    $P[$k]=0;
    $k--;
    goto EC2_Path_Extension;
    
    #[EC5 Advance Initial Vertex]
    EC5_Advance_Initial_Vertex:
    if($P[1] === N){
        goto EC6_Terminate;
    }
    $P[1]++;
    $k=1;
    $H=array(
            1=>array(1=>0,2=>0,3=>0,4=>0,5=>0),
            2=>array(1=>0,2=>0,3=>0,4=>0,5=>0),
            3=>array(1=>0,2=>0,3=>0,4=>0,5=>0),
            4=>array(1=>0,2=>0,3=>0,4=>0,5=>0),
            5=>array(1=>0,2=>0,3=>0,4=>0,5=>0)
    );
    goto EC2_Path_Extension;
    
    #[EC5 Advance Initial Vertex]
    EC6_Terminate:
    print_r($Circ);
    ?>
    

    then this is the other implementation, more independent of the graph, without goto and without array values, instead it uses array keys, the path, the graph and circuits are stored as array keys (use array values if you like, just change the required lines). The example graph start from -4 to show its independence.

    <?php
    
    $G = array(
            -4=>array(-4=>true,-3=>true,-2=>true),
            -3=>array(-4=>true,-3=>true,-2=>true),
            -2=>array(-4=>true,-3=>true,-2=>true)
    );
    
    
    $C = array();
    
    
    EC($G,$C);
    echo "<pre>";
    print_r($C);
    function EC($G, &$C){
    
        $CNST_not_closed =  false;                          // this flag indicates no closure
        $CNST_closed        = true;                         // this flag indicates closure
        // define the state where there is no closures for some node
        $tmp_first_node  =  key($G);                        // first node = first key
        $tmp_last_node  =   $tmp_first_node-1+count($G);    // last node  = last  key
        $CNST_closure_reset = array();
        for($k=$tmp_first_node; $k<=$tmp_last_node; $k++){
            $CNST_closure_reset[$k] = $CNST_not_closed;
        }
        // define the state where there is no closure for all nodes
        for($k=$tmp_first_node; $k<=$tmp_last_node; $k++){
            $H[$k] = $CNST_closure_reset;   // Key in the closure arrays represent nodes
        }
        unset($tmp_first_node);
        unset($tmp_last_node);
    
    
        # Start algorithm
        foreach($G as $init_node => $children){#[Jump to initial node set]
            #[Initial Node Set]
            $P = array();                   // declare at starup, remove the old $init_node from path on loop
            $P[$init_node]=true;            // the first key in P is always the new initial node
            $k=$init_node;                  // update the current node
                                            // On loop H[old_init_node] is not cleared cause is never checked again
            do{#Path 1,3,7,4 jump here to extend father 7
                do{#Path from 1,3,8,5 became 2,4,8,5,6 jump here to extend child 6
                    $new_expansion = false;
                    foreach( $G[$k] as $child => $foo ){#Consider each child of 7 or 6
                        if( $child>$init_node and isset($P[$child])===false and $H[$k][$child]===$CNST_not_closed ){
                            $P[$child]=true;    // add this child to the path
                            $k = $child;        // update the current node
                            $new_expansion=true;// set the flag for expanding the child of k
                            break(1);           // we are done, one child at a time
                }   }   }while(($new_expansion===true));// Do while a new child has been added to the path
    
                # If the first node is child of the last we have a circuit
                if( isset($G[$k][$init_node])===true ){
                    $C[] = $P;  // Leaving this out of closure will catch loops to
                }
    
                # Closure
                if($k>$init_node){                  //if k>init_node then alwaya count(P)>1, so proceed to closure
                    $new_expansion=true;            // $new_expansion is never true, set true to expand father of k
                    unset($P[$k]);                  // remove k from path
                    end($P); $k_father = key($P);   // get father of k
                    $H[$k_father][$k]=$CNST_closed; // mark k as closed
                    $H[$k] = $CNST_closure_reset;   // reset k closure
                    $k = $k_father;                 // update k
            }   } while($new_expansion===true);//if we don't wnter the if block m has the old k$k_father_old = $k;
            // Advance Initial Vertex Context
        }//foreach initial
    
    
    }//function
    
    ?>
    

    I have analized and documented the EC but unfortunately the documentation is in Greek.

    0 讨论(0)
  • 2020-11-22 06:23

    I found this page in my search and since cycles are not same as strongly connected components, I kept on searching and finally, I found an efficient algorithm which lists all (elementary) cycles of a directed graph. It is from Donald B. Johnson and the paper can be found in the following link:

    http://www.cs.tufts.edu/comp/150GA/homeworks/hw1/Johnson%2075.PDF

    A java implementation can be found in:

    http://normalisiert.de/code/java/elementaryCycles.zip

    A Mathematica demonstration of Johnson's algorithm can be found here, implementation can be downloaded from the right ("Download author code").

    Note: Actually, there are many algorithms for this problem. Some of them are listed in this article:

    http://dx.doi.org/10.1137/0205007

    According to the article, Johnson's algorithm is the fastest one.

    0 讨论(0)
  • 2020-11-22 06:28

    The DFS-based variants with back edges will find cycles indeed, but in many cases it will NOT be minimal cycles. In general DFS gives you the flag that there is a cycle but it is not good enough to actually find cycles. For example, imagine 5 different cycles sharing two edges. There is no simple way to identify cycles using just DFS (including backtracking variants).

    Johnson's algorithm is indeed gives all unique simple cycles and has good time and space complexity.

    But if you want to just find MINIMAL cycles (meaning that there may be more then one cycle going through any vertex and we are interested in finding minimal ones) AND your graph is not very large, you can try to use the simple method below. It is VERY simple but rather slow compared to Johnson's.

    So, one of the absolutely easiest way to find MINIMAL cycles is to use Floyd's algorithm to find minimal paths between all the vertices using adjacency matrix. This algorithm is nowhere near as optimal as Johnson's, but it is so simple and its inner loop is so tight that for smaller graphs (<=50-100 nodes) it absolutely makes sense to use it. Time complexity is O(n^3), space complexity O(n^2) if you use parent tracking and O(1) if you don't. First of all let's find the answer to the question if there is a cycle. The algorithm is dead-simple. Below is snippet in Scala.

      val NO_EDGE = Integer.MAX_VALUE / 2
    
      def shortestPath(weights: Array[Array[Int]]) = {
        for (k <- weights.indices;
             i <- weights.indices;
             j <- weights.indices) {
          val throughK = weights(i)(k) + weights(k)(j)
          if (throughK < weights(i)(j)) {
            weights(i)(j) = throughK
          }
        }
      }
    

    Originally this algorithm operates on weighted-edge graph to find all shortest paths between all pairs of nodes (hence the weights argument). For it to work correctly you need to provide 1 if there is a directed edge between the nodes or NO_EDGE otherwise. After algorithm executes, you can check the main diagonal, if there are values less then NO_EDGE than this node participates in a cycle of length equal to the value. Every other node of the same cycle will have the same value (on the main diagonal).

    To reconstruct the cycle itself we need to use slightly modified version of algorithm with parent tracking.

      def shortestPath(weights: Array[Array[Int]], parents: Array[Array[Int]]) = {
        for (k <- weights.indices;
             i <- weights.indices;
             j <- weights.indices) {
          val throughK = weights(i)(k) + weights(k)(j)
          if (throughK < weights(i)(j)) {
            parents(i)(j) = k
            weights(i)(j) = throughK
          }
        }
      }
    

    Parents matrix initially should contain source vertex index in an edge cell if there is an edge between the vertices and -1 otherwise. After function returns, for each edge you will have reference to the parent node in the shortest path tree. And then it's easy to recover actual cycles.

    All in all we have the following program to find all minimal cycles

      val NO_EDGE = Integer.MAX_VALUE / 2;
    
      def shortestPathWithParentTracking(
             weights: Array[Array[Int]],
             parents: Array[Array[Int]]) = {
        for (k <- weights.indices;
             i <- weights.indices;
             j <- weights.indices) {
          val throughK = weights(i)(k) + weights(k)(j)
          if (throughK < weights(i)(j)) {
            parents(i)(j) = parents(i)(k)
            weights(i)(j) = throughK
          }
        }
      }
    
      def recoverCycles(
             cycleNodes: Seq[Int], 
             parents: Array[Array[Int]]): Set[Seq[Int]] = {
        val res = new mutable.HashSet[Seq[Int]]()
        for (node <- cycleNodes) {
          var cycle = new mutable.ArrayBuffer[Int]()
          cycle += node
          var other = parents(node)(node)
          do {
            cycle += other
            other = parents(other)(node)
          } while(other != node)
          res += cycle.sorted
        }
        res.toSet
      }
    

    and a small main method just to test the result

      def main(args: Array[String]): Unit = {
        val n = 3
        val weights = Array(Array(NO_EDGE, 1, NO_EDGE), Array(NO_EDGE, NO_EDGE, 1), Array(1, NO_EDGE, NO_EDGE))
        val parents = Array(Array(-1, 1, -1), Array(-1, -1, 2), Array(0, -1, -1))
        shortestPathWithParentTracking(weights, parents)
        val cycleNodes = parents.indices.filter(i => parents(i)(i) < NO_EDGE)
        val cycles: Set[Seq[Int]] = recoverCycles(cycleNodes, parents)
        println("The following minimal cycle found:")
        cycles.foreach(c => println(c.mkString))
        println(s"Total: ${cycles.size} cycle found")
      }
    

    and the output is

    The following minimal cycle found:
    012
    Total: 1 cycle found
    
    0 讨论(0)
  • 2020-11-22 06:28

    DFS from the start node s, keep track of the DFS path during traversal, and record the path if you find an edge from node v in the path to s. (v,s) is a back-edge in the DFS tree and thus indicates a cycle containing s.

    0 讨论(0)
  • 2020-11-22 06:29

    First of all - you do not really want to try find literally all cycles because if there is 1 then there is an infinite number of those. For example A-B-A, A-B-A-B-A etc. Or it may be possible to join together 2 cycles into an 8-like cycle etc., etc... The meaningful approach is to look for all so called simple cycles - those that do not cross themselves except in the start/end point. Then if you wish you can generate combinations of simple cycles.

    One of the baseline algorithms for finding all simple cycles in a directed graph is this: Do a depth-first traversal of all simple paths (those that do not cross themselves) in the graph. Every time when the current node has a successor on the stack a simple cycle is discovered. It consists of the elements on the stack starting with the identified successor and ending with the top of the stack. Depth first traversal of all simple paths is similar to depth first search but you do not mark/record visited nodes other than those currently on the stack as stop points.

    The brute force algorithm above is terribly inefficient and in addition to that generates multiple copies of the cycles. It is however the starting point of multiple practical algorithms which apply various enhancements in order to improve performance and avoid cycle duplication. I was surprised to find out some time ago that these algorithms are not readily available in textbooks and on the web. So I did some research and implemented 4 such algorithms and 1 algorithm for cycles in undirected graphs in an open source Java library here : http://code.google.com/p/niographs/ .

    BTW, since I mentioned undirected graphs : The algorithm for those is different. Build a spanning tree and then every edge which is not part of the tree forms a simple cycle together with some edges in the tree. The cycles found this way form a so called cycle base. All simple cycles can then be found by combining 2 or more distinct base cycles. For more details see e.g. this : http://dspace.mit.edu/bitstream/handle/1721.1/68106/FTL_R_1982_07.pdf .

    0 讨论(0)
提交回复
热议问题