广度优先搜索一个顶点是否可以有一个相邻的顶点与不同的父顶点并被发现但未处理

问题描述

当使用没有平行边和自循环的广度优先搜索遍历无向图时，存在一个顶点 x 与相邻顶点 y。在处理顶点“x”时，它看到 y 已经被发现/访问过，并且有一个不是 x 的父/发现者，并且

• case 1) y 被处理
• 情况 2) y 未处理

每种情况发生的示例情况是什么？它是否说明了 x 和 y 之间的关系？

哪里， 处理顶点意味着我们已经遍历了它的所有相邻顶点 已发现节点意味着 y 至少已被其父节点之一发现。 Parent 是指第一个发现给定顶点的顶点。

这是我的想法。 显然，y 至少有 2 个父顶点。 “x”和至少一个父“a”。

 a    x
  \  /
    y

并且因为在 (1) 和 (2) 两种情况下都已经发现了 y

• （情况 1）是可能的，因为“a”和“x”（y 的父母）没有 任何共同的祖先或 x 必须在 y 之前被处理。 正确的？？？与否？

• (case 2) "a" 和 "x" 必须有一个共同的祖先，因此 x 是 在 y 之前处理。正确的？？？？与否？

仅供参考，这里是 bfs 的实现（参见 traverse() 函数），包括基于 Steven Skiena 的“算法设计手册”一书的 main()

#include <iostream>
#include <queue>




class edgeNode {
private:
    int y{ -1 };
    edgeNode* next{ nullptr };
public:
    edgeNode(int _y,edgeNode* _node) : y{ _y },next{ _node }{}
    edgeNode(int _y) : y{ _y },next(nullptr){}
    edgeNode() : y(0),next(nullptr) {}
    int getY() const { return y; }
    edgeNode* getNext() const { return next; }
    void print() { std::cout << y; }
};



class bGraph {
static  const int MAX_VERTICES = 100;
    edgeNode* edges[MAX_VERTICES];
    bool discovered[MAX_VERTICES];
    bool processed[MAX_VERTICES];
    int parents[MAX_VERTICES];

public:
    bGraph() {
        for (int i = 0; i < MAX_VERTICES; i++) {
            edges[i] = nullptr;
            discovered[i] = false;
            processed[i] = false;
            parents[i] = -1;    
        }
    }
    edgeNode* getEdge(int v) { return edges[v]; }
    void addEdge(int x,int y,bool directed) {
        edgeNode* node = new edgeNode(y,edges[x]);
        edges[x] = node;        
        if (!directed) {
            addEdge(y,x,true);
        }
    }

void traverse(int v) {
            int x,y;           
            std::queue<int> fifo;
            fifo.push(v);
            while (!fifo.empty()) {             
                x = fifo.front();
                fifo.pop();
                edgeNode* node = getEdge(x);
                if (node == nullptr)
                    continue;
                discovered[x] = true;
                std::cout << "\nStart Processing Vertex: " << x << std::endl; 
                while (node != nullptr) {
                    y = node->getY();
                    if (!processed[y] ) {
                        //process edge 
                        std::cout << "(" << x << "," << y << ") ";
                    }
                    if (!discovered[y]) {
                        fifo.push(y);
                        parents[y] = x;
                        discovered[y] = true;
                    }                   
                    node = node->getNext();
                }
                processed[x] = true;
            std::cout << "\nDone Processing Vertex: " << x << std::endl; 
            }
        }

};
int main()
{
bGraph g;
g.addEdge(1,2,false);
g.addEdge(3,1,false);
g.traverse(1);
    return 0;
}

解决方法

这是一个 BFS。离得近的人最先被注意到。

情况 1：y 被处理：如果从起始节点到 x 的最短路径经过 y。

关系：y 是 x 的祖先。

情况 2：y 未处理：如果从起始节点到 x 的最短路径未通过 y。

关系：y 不是 x 的祖先。

案例 3：是否在 y 之前处理 x 取决于您的实现。

关系：y 可能是也可能不是 x 的祖先。