146_leetcode_Clone Graph

最新推荐文章于 2025-09-11 19:19:55 发布

ezzffzz

最新推荐文章于 2025-09-11 19:19:55 发布

阅读量358

点赞数

CC 4.0 BY-SA版权

分类专栏：算法编程 leetcode 文章标签： leetcode 算法编程语言面试

本文链接：https://blog.youkuaiyun.com/ezzffzz/article/details/38067807

算法同时被 3 个专栏收录

155 篇文章

订阅专栏

编程

155 篇文章

订阅专栏

leetcode

155 篇文章

订阅专栏

本文介绍了一种高效的无向图克隆算法，通过两次广度优先遍历来复制图结构并建立新的邻接关系，利用unordered_map跟踪已访问节点。

Clone an undirected graph. Each node in the graph contains a label and a list of its neighbors.

OJ's undirected graph serialization:

Nodes are labeled uniquely.

We use # as a separator for each node, and , as a separator for node label and each neighbor of the node.

As an example, consider the serialized graph {0,1,2#1,2#2,2}.

The graph has a total of three nodes, and therefore contains three parts as separated by #.

First node is labeled as 0. Connect node 0 to both nodes 1 and 2.
Second node is labeled as 1. Connect node 1 to node 2.
Third node is labeled as 2. Connect node 2 to node 2 (itself), thus forming a self-cycle.

Visually, the graph looks like the following:

1:注意特殊情况，图的value值唯一；2:图由邻接链表组成；3:对图进行两次BFS(广度优先遍历）第一次分别复制相应的节点，第二次获得相应节点的邻接矩阵

4:使用unorder_map结构来实现判断当前节点是否已经访问过。

    UndirectedGraphNode *cloneGraph(UndirectedGraphNode *node)
    {
        if(node == NULL)
        {
            return NULL;
        }
        
        deque<UndirectedGraphNode *> myDeque;
        unordered_map<int, UndirectedGraphNode *> myMap;
        
        myDeque.push_back(node);
        
        while(!myDeque.empty())
        {
            UndirectedGraphNode *tmpNode = myDeque.front();
            myDeque.pop_front();
            
            if(myMap.find(tmpNode->label) == myMap.end())
            {
                UndirectedGraphNode *curNode = new UndirectedGraphNode(tmpNode->label);
                myMap[tmpNode->label] = curNode;
                
                for(int i = 0; i < (int)tmpNode->neighbors.size(); i++)
                {
                    myDeque.push_back(tmpNode->neighbors[i]);
                }
            }
        }
        
        myDeque.push_back(node);
        while(!myDeque.empty())
        {
            UndirectedGraphNode *tmpNode = myDeque.front();
            myDeque.pop_front();
            
            UndirectedGraphNode* curCloneNode = myMap[tmpNode->label];
            
            if(!tmpNode->neighbors.empty() && curCloneNode->neighbors.empty())
            {
                for(int i = 0; i < (int)tmpNode->neighbors.size(); i++)
                {
                    myDeque.push_back(tmpNode->neighbors[i]);
                    curCloneNode->neighbors.push_back(myMap[tmpNode->neighbors[i]->label]);
                }
            }
        }
        
        return myMap[node->label];
    }