Clone Graph BFS & DFS

最新推荐文章于 2020-10-23 00:24:03 发布

转载最新推荐文章于 2020-10-23 00:24:03 发布 · 661 阅读

C++ 专栏收录该内容

9 篇文章

订阅专栏

本文介绍了一种基于深广度优先搜索的图克隆算法，该算法能够有效处理图中存在的环问题。通过使用unordered_map记录原始节点与克隆节点之间的对应关系，避免重复克隆。此外，文章提供了DFS和BFS两种实现方式的具体代码示例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

变量unordered_map cloneMap;

因为会有环，所以需要cloneMap记录旧的节点和新的节点对。

还需要一个visited记录已经访问过的节点，可以和cloneMap合并在一起。

DFS：

在克隆某个Node时，首先放入map中。

之后遍历neighbors。如果neighbors不在map里，即没有访问过，则递归调用cloneGraph函数。

最后返回克隆过的节点。

 
        UndirectedGraphNode *cloneGraph(UndirectedGraphNode *node) {
       
        if
        (node == NULL) 
        return
        NULL;
       
        if
        (cloneMap.find(node) != cloneMap.end()) 
       
        return
        cloneMap[node];
       
        cloneMap[node] = 
        new
        UndirectedGraphNode(node->label);
       
        cloneMap[node]->neighbors = vector<undirectedgraphnode *=
        ""
        >();
       
        for
        (
        int
        i = 
        0
        ; i < node->neighbors.size(); i++)
       
        {
       
        UndirectedGraphNode * curNode = node->neighbors[i];
       
        UndirectedGraphNode * newNode = cloneGraph(curNode);
       
        cloneMap[node]->neighbors.push_back(newNode);
       
        }
       
        return
        cloneMap[node];
       
        }</undirectedgraphnode>

BFS：

使用一个queue记录要访问的节点。

因为不能在访问queue中节点的时候再创建对应的node==>因为在处理父亲节点的时候需同时创建好其neighbors

所以需要在将不在map中的neighbors（没有访问过的子节点）放入queue的同时创建克隆的节点，并且放入map里。

 
        UndirectedGraphNode *cloneGraph(UndirectedGraphNode *node) {
       
        if
        (node == NULL) 
        return
        NULL;
       
        vector<undirectedgraphnode *=
        ""
        > queue;
       
        queue.push_back(node);
       
        cloneMap[node] = 
        new
        UndirectedGraphNode(node->label);
       
        cloneMap[node]->neighbors = vector<undirectedgraphnode *=
        ""
        >();
       
        for
        (
        int
        i = 
        0
        ; i < queue.size(); i++)
       
        {
       
        UndirectedGraphNode * newNode = cloneMap[queue[i]];
       
        for
        (
        int
        j = 
        0
        ; j < queue[i]->neighbors.size(); j++)
       
        {
       
        UndirectedGraphNode * curNb = queue[i]->neighbors[j];
       
        if
        (cloneMap.find(curNb) == cloneMap.end())
       
        {
       
        queue.push_back(curNb);
       
        UndirectedGraphNode * newNb = 
        new
        UndirectedGraphNode(curNb->label);
       
        newNb->neighbors = vector<undirectedgraphnode *=
        ""
        >();
       
        cloneMap[curNb] = newNb;
       
        }
       
        newNode->neighbors.push_back(cloneMap[curNb]);
       
        }
       
        }
       
        return
        cloneMap[node];
       
        }</undirectedgraphnode></undirectedgraphnode></undirectedgraphnode>