[LeetCode] Clone Graph

最新推荐文章于 2019-07-20 20:47:16 发布

yongyongjiaojiao

最新推荐文章于 2019-07-20 20:47:16 发布

阅读量305

点赞数

CC 4.0 BY-SA版权

分类专栏： LeetCode

本文链接：https://blog.youkuaiyun.com/jinyonghorse/article/details/12906111

LeetCode 专栏收录该内容

144 篇文章

订阅专栏

本文详细介绍了如何使用映射、宽搜等技术克隆无向图，并提供了具体实现代码，适合对图论和算法感兴趣的读者深入学习。

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:

克隆图

使用一个map，保存新图节点到原图的映射，

宽搜当前的图，将每一层的链接关系连接好

/**
 * Definition for undirected graph.
 * struct UndirectedGraphNode {
 *     int label;
 *     vector<UndirectedGraphNode *> neighbors;
 *     UndirectedGraphNode(int x) : label(x) {};
 * };
 */
class Solution {
public:
    UndirectedGraphNode *cloneGraph(UndirectedGraphNode *node) {
        // Note: The Solution object is instantiated only once and is reused by each test case.
        if(node == NULL) return NULL;
        map<int,UndirectedGraphNode *> copy;
        set<int> visited;
        vector<UndirectedGraphNode *> next;
        next.push_back(node);
        copy[node->label] = new UndirectedGraphNode(node->label);
        while(next.size() > 0) {
            vector<UndirectedGraphNode *> pre;
            for(int i = 0; i < next.size(); i++) {
                UndirectedGraphNode *tmp = next[i];
                if(copy.find(tmp->label) == copy.end()) copy[tmp->label] = new UndirectedGraphNode(tmp->label);
                UndirectedGraphNode *copyNode = copy[tmp->label];
                
                visited.insert(tmp->label);
                vector<UndirectedGraphNode *> neigh =tmp->neighbors;
                for(int i = 0; i < neigh.size(); i++) {
                    UndirectedGraphNode *t = neigh[i];
                    if(copy.find(t->label) == copy.end()) copy[t->label] = new UndirectedGraphNode(t->label);
                    copyNode->neighbors.push_back(copy[t->label]);
                    if(visited.count(t->label) == 0) {
                        visited.insert(t->label);
                        pre.push_back(t);
                    }
                }
            }
            next.clear();
            next.assign(pre.begin(),pre.end());
        }
        return copy[node->label];        
    }
};