leetcode 133. Clone Graph

最新推荐文章于 2021-12-18 21:11:27 发布

原创最新推荐文章于 2021-12-18 21:11:27 发布 · 203 阅读

0 ·

CC 4.0 BY-SA版权

leetcode 专栏收录该内容

280 篇文章

订阅专栏

本文介绍了一种无向图的克隆算法实现，通过广度优先搜索获取原始图的所有节点，并创建新的节点副本，最后复制节点间的连接关系。文章包含完整的C++代码示例。

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:

/**
 * Definition for undirected graph.
 * struct UndirectedGraphNode {
 *     int label;
 *     vector<UndirectedGraphNode *> neighbors;
 *     UndirectedGraphNode(int x) : label(x) {};
 * };
 */
class Solution {
public:
    UndirectedGraphNode *cloneGraph(UndirectedGraphNode *node) 
    {
        if (!node)
            return NULL;
        
        vector<UndirectedGraphNode *> graph = get_graph(node);//BFS搜索，返回原本的点集
        
        //copy point
        map<UndirectedGraphNode *,UndirectedGraphNode *> mm;  //新旧点集对应
        for(int i = 0; i < graph.size(); i++)
        {
            UndirectedGraphNode* p = new UndirectedGraphNode(graph[i]->label);
            mm[graph[i]] = p;
        }
        
        //copy edges
        for(int i = 0; i < graph.size(); i++)
        {
            UndirectedGraphNode* pNew = mm[graph[i]];    
            for(int j = 0; j < graph[i]->neighbors.size(); j++)
            {
                UndirectedGraphNode * pNei = mm[graph[i]->neighbors[j]];
                pNew->neighbors.push_back(pNei);
            }
        }
        return mm[graph[0]];
    }
    
    //BFS 搜索一遍点集
    vector<UndirectedGraphNode *> get_graph(UndirectedGraphNode * node)
    {
        vector<UndirectedGraphNode *> hash;
        queue<UndirectedGraphNode *> Nodes;
        Nodes.push(node);
        hash.push_back(node);

        while (!Nodes.empty())
        {
            UndirectedGraphNode *p = Nodes.front();
            Nodes.pop();
            for(int i = 0; i < p->neighbors.size(); i++)
            {
                if(find(hash.begin(), hash.end(), p->neighbors[i]) == hash.end())
                {
                    hash.push_back(p->neighbors[i]);
                    Nodes.push(p->neighbors[i]);
                }
            }
        }
        return hash;
    }    
};