【Clone Graph】cpp

题目：

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 #.

1. First node is labeled as 0. Connect node 0 to both nodes 1 and 2.
2. Second node is labeled as 1. Connect node 1 to node 2.
3. 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
      / \
     /   \
    0 --- 2
         / \
         \_/

代码：

/**
 * Definition for undirected graph.
 * struct UndirectedGraphNode {
 *     int label;
 *     vector<UndirectedGraphNode *> neighbors;
 *     UndirectedGraphNode(int x) : label(x) {};
 * };
 */
class Solution {
public:
        UndirectedGraphNode *cloneGraph(UndirectedGraphNode *node)
        {
            map<UndirectedGraphNode *, UndirectedGraphNode *> copied;
            return Solution::dfs(copied, node);
        }
        static UndirectedGraphNode *dfs(
            map<UndirectedGraphNode *, UndirectedGraphNode *>& copied,
            UndirectedGraphNode *node)
        {
            if ( node == NULL) return NULL;
            if ( copied.find(node)!=copied.end() ) return copied[node];
            UndirectedGraphNode *cloneNode = new UndirectedGraphNode(node->label);
            copied[node] = cloneNode;
            for ( int i=; i<node->neighbors.size(); ++i )
            {
                cloneNode->neighbors.push_back( Solution::dfs(copied,node->neighbors[i]) );
            }
            return cloneNode;
        }
};

tips：

图的深拷贝。

学到的一个技巧是如何不重复拷贝图中的node：用一个map<node *, node *>记录已经拷贝过的原图中的点以及其对应的新图中的点。

剩下的就是按照深搜模板来完成。

====================================

第二次过这道题，照着之前的思路写，漏掉了重要的红字的部分。

/**
 * Definition for undirected graph.
 * struct UndirectedGraphNode {
 *     int label;
 *     vector<UndirectedGraphNode *> neighbors;
 *     UndirectedGraphNode(int x) : label(x) {};
 * };
 */
class Solution {
public:
        UndirectedGraphNode *cloneGraph(UndirectedGraphNode *node)
        {
            map<UndirectedGraphNode*, UndirectedGraphNode*> originCopy;
            return Solution::dfs(node, originCopy);
        }
        static UndirectedGraphNode* dfs(
            UndirectedGraphNode* origin,
            map<UndirectedGraphNode*, UndirectedGraphNode*>& originCopy)
        {
            if ( !origin ) return NULL;
            if ( originCopy.find(origin)!=originCopy.end() ) return originCopy[origin];
            UndirectedGraphNode* copy = new UndirectedGraphNode(origin->label);
            originCopy[origin] = copy;
            for ( int i=; i<origin->neighbors.size(); ++i )
            {
                copy->neighbors.push_back(Solution::dfs(origin->neighbors[i], originCopy));
            }
            return copy;
        }
};