检测未连接图中的周期

Question

Although there are a few questions on this topic, i would need some piece of advice in a more specific matter.

I am working on some project where i have to rename an entity. This implies saving a new object containing the old and the new name of the entity. This is how the soft works.

Now, what i have to do is check if a circular dependency is attempted when someone tries to rename an object. For example:

A -> B
B -> C
C -> A

When someone tries to rename C into A, this should be signaled.

I am not sure how to approach this problem. My thought was to create a directed graph having the edges[A, B], [B, C], [C, A] and the apply some cycle detecting algorithms to find the circular dependencies (Tarjan or something).

Would that be efficient considering that the graph will not be connected? It is possible to have the aforementioned example and then:

E -> F
H -> J
X -> Y

I will end up with a lot of unconnected edges and a few cycles maybe. Should i first find the smaller, connected graphs and apply whatever algorithm on each or is there a possibility to just add build the big one and apply the algorithm on it?

What is the fastest and recommended way to detect the circular dependencies for my example?

Thank you!

Update I have come up with the following dfs approach:

void DFS(int root, boolean[] visited){
        onStack = new boolean[N];
        edgeTo = new int[N];

        visited[root]=true;
        onStack[root] = true;

        for (int i=0; i<N; ++i){
            if (G[root][i]){ 
                if(!visited[i]){
                   DFS(i,visited);
                } else if (onStack[i]){
                   System.out.printf("%nCycle %n");
                }
          } else {
              System.out.printf("%nG[" + root + "][" + i + "] is not an edge%n");
          }

          onStack[root] = false;
        }

    }

and calling it like this:

void DFS()
    {
        boolean[] visited =new boolean[N]; 
        int numComponets=0;

        // do the DFS from each node not already visited
        for (int i=0; i<N; ++i)
            if (!visited[i] && cycle == null)
            {
                ++numComponets;             
                DFS(i,visited);
            } 
    }

And it successfully finds the connected components, but does not recognize any cycle, only if i remove the G[root][i] condition, that would be the first cycle from 0 to 0. What am i missing?

Answer 1

If I understood your problem correctly, you'll only get a circular dependency when someone changes the name of the entity to a name previously used by that entity.

Taking this into account why not just make a collection with all the names the entity had and whenever a user tries to change the name check if the name is in your collection or not. If it is, then this will create a circular dependency, if it's not in your collection then add it to the collection and allow the name changing operation to continue.

A collection like HashSet would be useful for this approach since it gives you an average O(1) time complexity for element lookup.

Answer 2

You can simply maintain a set S of all nodes. Then you take a node from that set, run dfs/bfs on that node, checking for back edges (if so, you know you have a cycle). For each node you visit, remove that node from the set S . After dfs/bfs is finished, you check if S is empty. If so, then you know there are no cycles. Otherwise, you take a node from S , and run dfs/bfs on that node. The runtime should be O(n), where n is the number of nodes.

Pseudocode:

S = set(all nodes)
while len(S) > 0:
    node = S.pop()
    stack = [node]
    visited = set()
    while len(stack) > 0:
        node = stack.pop()
        visited.add(node)
        S.remove(node)
        for each neighbor of node in your graph:
            if neighbor in visited:
                # you know you have a cycle

            else:
                stack.append(node)