Clone Graph

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

 解析：

1 先复制节点，再复制节点的neighbors关系。

2 label是唯一的，可以用label作为Map的key，以确定哪些节点已经复制。

 代码如下：

package leetcode;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class CloneGraph {
    class UndirectedGraphNode {
        int label;
        List<UndirectedGraphNode> neighbors;
        Set<UndirectedGraphNode> set = new HashSet<CloneGraph.UndirectedGraphNode>();

        UndirectedGraphNode(int x) {
            label = x;
            neighbors = new ArrayList<UndirectedGraphNode>();
        }

        public String toString(Set<UndirectedGraphNode> set) {
            if (set.contains(this)) {
                return "";
            }
            set.add(this);

            String s = label + ",";
            for (UndirectedGraphNode neighbor : neighbors) {
                s += neighbor.label + ",";
            }
            s += "#";

            for (UndirectedGraphNode neighbor : neighbors) {
                s += neighbor.toString(set);
            }
            return s;
        }

        @Override
        public String toString() {
            set.clear();
            return toString(set);
        }
    };

    private void cloneNode(UndirectedGraphNode node, Map<Integer, UndirectedGraphNode> map) {

        if (map.containsKey(node.label)) {
            return;
        }
        
        UndirectedGraphNode nodeClone = new UndirectedGraphNode(node.label);
        map.put(node.label, nodeClone);
        for (UndirectedGraphNode neighbor : node.neighbors) {
            cloneNode(neighbor, map);
        }
        return;
    }

    private void cloneNeighbors(UndirectedGraphNode node, UndirectedGraphNode nodeClone, Map<Integer, UndirectedGraphNode> map) {
        
        if (node.neighbors.size() == nodeClone.neighbors.size()) {
            return;
        }
        
        for (UndirectedGraphNode neighbor : node.neighbors) {
            nodeClone.neighbors.add(map.get(neighbor.label));
        }
        
        for (UndirectedGraphNode neighbor : node.neighbors) {
            cloneNeighbors(neighbor, map.get(neighbor.label), map);
        }
    }

    public UndirectedGraphNode cloneGraph(UndirectedGraphNode node) {
        if (node == null) {
            return null;
        }

        // 复制节点
        Map<Integer, UndirectedGraphNode> map = new HashMap<Integer, UndirectedGraphNode>();
        cloneNode(node, map);
        
        UndirectedGraphNode nodeClone = map.get(node.label);

        // 复制neighbors关系
        cloneNeighbors(node, nodeClone, map);
        
        return nodeClone;
    }
}

2 题外话

本题有坑：

(1) 无向图，node2是node1的neighbors，不代表node1是node2的neighbors。

本来是准备将nodeClone挂到node的最后一个neighbors，然后复制nodeClone的neighbors关系，再断开node和nodeClone的连接。

这样时间复杂度为O(n)，空间复杂度O(1)。

这么做的瓶颈在于最后无法区分哪些是node的节点，哪些是clone的节点。这个需要存在如下假设：有node1.neighbors.contains(node2)，则必有node2.neighbors.contains(node1)。

(2) 本题label唯一不通用，可以取node作为Map的key，这就需要为UndirectedGraphNode添加node的hashCode()和equals()方法，而leetcode是不允许修改这个的。一方面，平时我们是可以修改类的；另一方面，我们可以创建UndirectedGraphNode的子类，计算完成后，将结果强转为父类。