What is the most effiecent alogrithm for detecting all cycles within a directed graph?
or
I have a directed graph representing a schedule of jobs that need to be exectuted, 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.
Tarjan's strongly connected components algorithm has O(E + V) complexity
For other algorithm see Strongly connected components on Wikipedia
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 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 http://en.wikipedia.org/wiki/Topological_sorting has pseudo-code for one algorithm, and a brief description of another from Tarjan. Both have O(V + E) complexity.
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.
The way I do it is to do a Topological Sort, counting the number of vertices visited. If that number is less than the total number of vertices in the DAG, you have a cycle.
Hi,well the simplest way to do it is to do a depth first traversal of the graph. If the graph has v vertices, this is of O(v). Since you will (possibly) have to do a DFT starting from each possible vertex, the total complexity becomes O(v^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!
if a graph satisfy this property if |e|>|v|-1; than a graph contain at least on cycle in the graph