Algorithm 无向图中的圈检测

为了检测无向图中的循环， 给出了以下代码anf算法；我使用的是标准宽度优先遍历，并做了一些轻微的修改：

void bfsUtil(int s,vector<bool> &visited,vector<int> adj[],vector<int> &visits) {
    queue<int> q;
    q.push(s);
    visits[s]++;
    visited[s]=true;
    while(!q.empty()) {
        int vertex=q.front();
        q.pop();
        for(int i=0;i<adj[vertex].size();i++) {
            if(!visited[adj[vertex][i]]) {
                visited[adj[vertex][i]]=true;
                q.push(adj[vertex][i]);
                visits[adj[vertex][i]]++;
            } else {
                visits[adj[vertex][i]]++;
            }
        }
    }

}

/* This function is used to detect a cycle in undirected graph
*  adj[]: array of vectors to represent graph
*  V: number of vertices
*/
bool isCyclic(vector<int> adj[], int V)
{
   vector<int> visits(V,0);
   vector<bool> visited(V,false);
   for(int i=0;i<V;i++){
       if(!visited[i]) {
          bfsUtil(i,visited,adj,visits);
       }
   }
   for(int i=0;i<visits.size();i++) {
       if(visits[i]>2) {
           return true;
       }
   }
   return false;
}

Algorithm:

    1. Normal Breadth first search and maintaining a count aray for the no of visits of each vertex.
    2. If no of visits>2 
             print cycle is present 
        else
             print no cycle

---

我的算法哪里出错了？

你的算法错了。考虑以下边的图：

0 - 1
0 - 2

当当前节点为1时，它还会检查0，因为还有一条从1到0的边。因此，它将增加0的访问次数。同样，2也会增加计数。因此，您的代码总是错误地检测周期

要解决这个问题，您应该为每个节点保留一个父节点，从那里访问节点。当你检查时，你不应该考虑父母的优势。 最后，您不需要访问数组。如果您发现一个相邻的节点不是当前节点的父节点，但之前仍然被访问过，那么您可以断定存在一个循环

修改您的代码：

bool bfsUtil(int s,vector<bool> &visited,vector<int> adj[],vector<int> &parent) {
    queue<int> q;
    q.push(s);
    visited[s]=true;
    while(!q.empty()) {
        int vertex=q.front();
        q.pop();
        for(int i=0;i<adj[vertex].size();i++) {
            if(adj[vertex][i] == parent[vertex])
                continue;
            if(!visited[adj[vertex][i]]) {
                visited[adj[vertex][i]]=true;
                q.push(adj[vertex][i]);
                parent[adj[vertex][i]] = vertex;
            } else {
                //cycle detected;
                return true;
            }
        }
    }
    return false;
}

/* This function is used to detect a cycle in undirected graph
*  adj[]: array of vectors to represent graph
*  V: number of vertices
*/
bool isCyclic(vector<int> adj[], int V)
{

   vector<bool> visited(V,false);
   vector<int> parent(V, -1); // -1 means no parent assigned
   for(int i=0;i<V;i++){
       if(!visited[i]) {
          if(bfsUtil(i,visited,adj,parent)) return true;
       }
   }

   return false;
}

bool bfsUtil（整数、向量和访问、向量调整[]、向量和父对象）{
队列q；
q、 推；
已访问=正确；
而（！q.empty（））{
int-vertex=q.front（）；
q、 pop（）；
对于（int i=0；i
bool bfsUtil(int s,vector<bool> &visited,vector<int> adj[],vector<int> &parent) {
    queue<int> q;
    q.push(s);
    visited[s]=true;
    while(!q.empty()) {
        int vertex=q.front();
        q.pop();
        for(int i=0;i<adj[vertex].size();i++) {
            if(adj[vertex][i] == parent[vertex])
                continue;
            if(!visited[adj[vertex][i]]) {
                visited[adj[vertex][i]]=true;
                q.push(adj[vertex][i]);
                parent[adj[vertex][i]] = vertex;
            } else {
                //cycle detected;
                return true;
            }
        }
    }
    return false;
}

/* This function is used to detect a cycle in undirected graph
*  adj[]: array of vectors to represent graph
*  V: number of vertices
*/
bool isCyclic(vector<int> adj[], int V)
{

   vector<bool> visited(V,false);
   vector<int> parent(V, -1); // -1 means no parent assigned
   for(int i=0;i<V;i++){
       if(!visited[i]) {
          if(bfsUtil(i,visited,adj,parent)) return true;
       }
   }

   return false;
}