了解Skiena的算法以检测图中的循环

Question

I'm having trouble understanding everything in Skeina's algorithm to detect cycles in a graph whether directed or undirected

void process_edge(int v, int y) {
    // if parent[v] == y it means we're visitng the same edge since this is unweighted?
    // y must be discovered otherwise this is the first I'm seeing it?
    if (discovered[y] && parent[v] != y) {
        printf("\nfound a back edge (%d %d) \n", v, y);
    }
}

void DFSRecursive(graph *g, int v) {
    discovered[v] = true;

    edge *e = g->edges[v];
    while (e != NULL) {
        int y = e->y;
        if (discovered[y] == false) {
            parent[y] = v;
            DFSRecursive(g, y);
        } else if (!processed[y] || g->directed) { // can't be processed and yet has an unvisited kid!?
            process_edge(v, y, data);
        }
        e = e->next;
    }

    processed[v] = true;
}

1. Why are we checking !processed[y]? If we see a neighbor y and it was discovered already (first if condition), how would it be possible that y has been processed? given that v is a neighbor and we discovered it just now?
2. I was confused with the check for parent[v] !== y but I guess it makes sense in the unweighted graph case, if we have a graph with just two nodes, both nodes have each other in their adjacency so this is not a cycle. I'm not clear though on why it would make sense in the directed case because 1->2 and 2->1 is considered a cycle, right?
3. I don't have problems with the third condition discovered[y] in the process edge method because if it undiscovered, it would mean this is the first time we are seeing it

Answer 1

I was confused with the check for parent[v] !== y but I guess it makes sense in the unweighted graph case, if we have a graph with just two nodes, both nodes have each other in their adjacency so this is not a cycle. I'm not clear though on why it would make sense in the directed case because 1->2 and 2->1 is considered a cycle, right?

I disagree with the other answers on this. A cycle does not visit an edge multiple times, otherwise any graph with an edge, directed or not, would have a cycle. The algorithm given in the book is correct. The check is only needed for undirected graphs, but the code handles both very cleanly in my opinion.

If you're referring to a case when we might have two directed edges:

1 -> 2
2 -> 1

Then whether or not you consider this a cycle is debatable. In general, directed graphs are assumed not to have such cases. I can interpret such a pair as an undirected edge, and then it won't make sense to walk it twice. You can interpret it as two directed edges, and then you'd be right that the algorithm is wrong. But it would only be wrong for your interpretation.

For the interpretation most often used (and easiest to understand), the algorithm does what it's supposed to.

As another example, one can also allow edges like 1 -> 1 . Would you consider this a cycle? You wouldn't be wrong either way. It's just a matter of definitions. For textbooks, one usually works with the definition that lets the author present the most convenient (easiest to understand) solution.

Answer 2

1. It is possible for directed graphs. Let's assume that we a have graph with 2 vertices and 1 edge: 2 -> 1. If we start the depth-first search from the first vertex, it will be processed by the time we visit the second vertex. So an edge 2 -> 1 will lead to a processed vertex. It is not possible for undirected graphs, though.

2. I agree with you here.

The main issue with this code, in my opinion, is that it tries to handle both: directed and undirected graphs at the same time, which makes the logic unclear and hard to follow. Detecting cycles in a graph using depth-first search is actually pretty easy, so I would just recommend finding a better implementation(or making your own, which handles directed and undirected graphs separately).