# algorithm - undirected - print cycle in directed graph

## Best algorithm for detecting cycles in a directed graph (9)

Tarjan's strongly connected components algorithm has `O(|E| + |V|)`

time complexity.

For other algorithms, see Strongly connected components on Wikipedia.

What is the most efficient algorithm for detecting all cycles within a directed graph?

I have a directed graph representing a schedule of jobs that need to be executed, a job being a node and a dependency being an edge. I need to detect the error case of a cycle within this graph leading to cyclic dependencies.

https://mathoverflow.net/questions/16393/finding-a-cycle-of-fixed-length I like this solution the best specially for 4 length:)

Also phys wizard says u have to do O(V^2). I believe that we need only O(V)/O(V+E). If the graph is connected then DFS will visit all nodes. If the graph has connected sub graphs then each time we run a DFS on a vertex of this sub graph we will find the connected vertices and wont have to consider these for the next run of the DFS. Therefore the possibility of running for each vertex is incorrect.

Given that this is a schedule of jobs, I suspect that at some point you are going to *sort* them into a proposed order of execution.

If that's the case, then a *topological sort* implementation may in any case detect cycles. UNIX `tsort`

certainly does. I think it is likely that it is therefore more efficient to detect cycles at the same time as tsorting, rather than in a separate step.

So the question might become, "how do I most efficiently tsort", rather than "how do I most efficiently detect loops". To which the answer is probably "use a library", but failing that the following Wikipedia article:

has the pseudo-code for one algorithm, and a brief description of another from Tarjan. Both have `O(|V| + |E|)`

time complexity.

I had implemented this problem in sml ( imperative programming) . Here is the outline . Find all the nodes that either have an indegree or outdegree of 0 . Such nodes cannot be part of a cycle ( so remove them ) . Next remove all the incoming or outgoing edges from such nodes. Recursively apply this process to the resulting graph. If at the end you are not left with any node or edge , the graph does not have any cycles , else it has.

If a graph satisfy this property

```
|e| > |v| - 1
```

then the graph contains at least on cycle.

If you can't add a "visited" property to the nodes, use a set (or map) and just add all visited nodes to the set unless they are already in the set. Use a unique key or the address of the objects as the "key".

This also gives you the information about the "root" node of the cyclic dependency which will come in handy when a user has to fix the problem.

Another solution is to try to find the next dependency to execute. For this, you must have some stack where you can remember where you are now and what you need to do next. Check if a dependency is already on this stack before you execute it. If it is, you've found a cycle.

While this might seem to have a complexity of O(N*M) you must remember that the stack has a very limited depth (so N is small) and that M becomes smaller with each dependency that you can check off as "executed" plus you can stop the search when you found a leaf (so you **never** have to check every node -> M will be small, too).

In MetaMake, I created the graph as a list of lists and then deleted every node as I executed them which naturally cut down the search volume. I never actually had to run an independent check, it all happened automatically during normal execution.

If you need a "test only" mode, just add a "dry-run" flag which disables the execution of the actual jobs.

Start with a DFS: a cycle exists if and only if a *back-edge is discovered during DFS*. This is proved as a result of white-path theorum.

The simplest way to do it is to *do a depth first traversal (DFT) of the graph*.

If the graph has `n`

vertices, this is a `O(n)`

time complexity algorithm. Since you will possibly have to do a DFT starting from each vertex, the total complexity becomes `O(n^2)`

.

You have to maintain a *stack containing all vertices in the current depth first traversal*, with its first element being the root node. If you come across an element which is already in the stack during the DFT, then you have a cycle.

There is no algorithm which can find all the cycles in a directed graph in polynomial time. Suppose, the directed graph has n nodes and every pair of the nodes has connections to each other which means you have a complete graph. So any non-empty subset of these n nodes indicates a cycle and there are 2^n-1 number of such subsets. So no polynomial time algorithm exists. So suppose you have an efficient (non-stupid) algorithm which can tell you the number of directed cycles in a graph, you can first find the strong connected components, then applying your algorithm on these connected components. Since cycles only exist within the components and not between them.