133. Clone Graph

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
         / \
         \_/

---

图的复制问题
图的问题，一般可以考虑用BFS或者DFS解决：BFS适合最短路径问题，DFS适合记录所有路径问题。这道题没有特别要求，两种方法都可行。
图包括点和边。点可以依靠BFS或者DFS来遍历，边需要loop每个点的neighbors。
不管使用何种方法，都需要利用哈希表来记录已经复制的节点。

方法一：使用BFS
数据结构：
BFS -> queue
避免重复拷贝-> 哈希表 unordered_map

/**
 * 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==NULL){
            return node;
        }
        
        unordered_map<UndirectedGraphNode*, UndirectedGraphNode*> visited;
        queue<UndirectedGraphNode*> queue;
        
        visited[node] = new UndirectedGraphNode(node->label); //copy node
        queue.push(node);   //push node into queue
        
        //BFS: 
        while(!queue.empty()){
            UndirectedGraphNode* curr = queue.front();
            queue.pop();
            
            for(UndirectedGraphNode* neighbor: curr->neighbors){
                if(visited.find(neighbor)==visited.end()){ //new node
                    visited[neighbor] = new UndirectedGraphNode(neighbor->label); //copy node
                    queue.push(neighbor);   //
                }
                //copy edge: neighbor clone should have happened if needed, otherwise, we cannot clone edge 
                visited[curr]->neighbors.push_back(visited[neighbor]);
            }
        }
        
        return visited[node];
    }
};

方法二：使用DFS

同样需要使用哈希表来记录点有没有遍历过。DFS通常可以通过recursion或者利用stack来实现。

1. 使用recursion

/**
 * 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==NULL){
            return node;
        }
        
        unordered_map<UndirectedGraphNode*,UndirectedGraphNode*> visited;
        return dfs(visited,node);
    }
private:
    //DFS focus on current node: clone node, clone edges that are originated from this node  
    UndirectedGraphNode* dfs(unordered_map<UndirectedGraphNode*,UndirectedGraphNode*>& visited, UndirectedGraphNode* node){
        visited[node]=new UndirectedGraphNode(node->label); //copy node (itself), and store it in hash map
        for(UndirectedGraphNode* neighbor: node->neighbors){ //copy all edges (originated from current node)
            if(visited.find(neighbor)==visited.end()){ //recursively dfs on this neighbor
                dfs(visited,neighbor);
            }
            //copy edge: clone of the edge (node->neighbor)
            visited[node]->neighbors.push_back(visited[neighbor]);
        }
        return visited[node];
    } 
};

 

2. 使用stack

/**
 * 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 node;
        }
        
        unordered_map<UndirectedGraphNode*, UndirectedGraphNode*> visited;
        stack<UndirectedGraphNode*> stack;
        
        stack.push(node);
        visited[node]=new UndirectedGraphNode(node->label);
        
        //use stack to iteratively implement dfs
        while(!stack.empty()){
            UndirectedGraphNode* curr = stack.top();
            stack.pop();
            
            for(UndirectedGraphNode* neighbor: curr->neighbors){
                if(visited.find(neighbor)==visited.end()){//new node, not cloned yet
                    visited[neighbor] = new UndirectedGraphNode(neighbor->label); //copy new node
                    stack.push(neighbor); //into stack to clone edges
                }
                //edge clone: neighbor clone should have happened if needed, otherwise we cannot clone edge
                visited[curr]->neighbors.push_back(visited[neighbor]);
            }
        }
        
        return visited[node];
    }
};

 

confusion: 细节部分，

1. code采用在while循环外复制根结点，在for循环内复制每个未遍历过的邻居结点，为什么？=>不准确，上面的三种实现方法的code，DFS with recursion方法是在dfs内先clone自己，然后在for循环recursively call DFS，并复制边。

2. 可否在while循环内，for循环外复制节点？=>见下面的分析

分析：

当借助于特殊的数据结构来做遍历时，i.e., BFS利用queue，DFS利用stack: 在利用for循环loop邻居试图clone边时，必须保证该邻居节点已经被clone，然后才能clone此边（把clone的邻居节点放到该节点的clone的邻居里）；as a comparison, 如果是利用recursion，recursively call DFS on 邻居节点，当recursion返回时，邻居节点已经clone完成，因此可以直接clone 边。DFS with recursion需要清楚的知道对于该节点，需要做的是什么，在这里是：clone 自己，for 循环loop每个邻居，recursively call recursion on each neighbor to clone it, clone该节点到所有邻居的边。 

当然，DFS with recursion 也可以在DFS外先clone节点，然后在DFS该节点是不需要clone自己，需要做的是clone每个邻居节点+该节点到邻居clone的边。评价：这种实现方法很不直观，因为这种DFS需要对该节点和邻居节点同时进行操作，e.g.，clone邻居节点，clone该节点到邻居节点的边；而不是focus在该节点上，这种实现容易导致混乱的逻辑。