【Leetcode】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 #.

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:

Java：

新的DFS:http://rleetcode.blogspot.com/2014/01/clone-graph-java.html

/**
 * Definition for undirected graph.
 * class UndirectedGraphNode {
 *     int label;
 *     List<UndirectedGraphNode> neighbors;
 *     UndirectedGraphNode(int x) { label = x; neighbors = new ArrayList<UndirectedGraphNode>(); }
 * };
 */
public class Solution {
    public UndirectedGraphNode cloneGraph(UndirectedGraphNode node) {
        //DFS;
        if(node==null) return null;
       
       HashMap<Integer,UndirectedGraphNode> map= new HashMap<Integer,UndirectedGraphNode>();
    
       return clone(node,map);
    }
    private UndirectedGraphNode clone(UndirectedGraphNode node, HashMap<Integer,UndirectedGraphNode> map){
        if(map.containsKey(node.label))
        {
            return map.get(node.label);
        }
        UndirectedGraphNode newNode= new UndirectedGraphNode(node.label);
        map.put(node.label,newNode);
            for(UndirectedGraphNode nei : node.neighbors)
           {
               newNode.neighbors.add(clone(nei,map));
           }
           return newNode;
    }
}

http://blog.youkuaiyun.com/linhuanmars/article/details/22715747

广度优先：

定义一个队列用来存每层每个节点的邻居，定义一个hashmap存<原图，复制>的键值对。

外层循环检查队列是否为空，内层循环遍历每个节点的所有邻居

/**
 * Definition for undirected graph.
 * class UndirectedGraphNode {
 *     int label;
 *     List<UndirectedGraphNode> neighbors;
 *     UndirectedGraphNode(int x) { label = x; neighbors = new ArrayList<UndirectedGraphNode>(); }
 * };
 */
public class Solution {
    public UndirectedGraphNode cloneGraph(UndirectedGraphNode node) {
        if(node==null) return null;
        LinkedList<UndirectedGraphNode> queue= new LinkedList<UndirectedGraphNode>();
        HashMap<UndirectedGraphNode, UndirectedGraphNode> map= new HashMap<UndirectedGraphNode, UndirectedGraphNode>();
        UndirectedGraphNode copy= new UndirectedGraphNode(node.label);
        map.put(node, copy);
        queue.offer(node);
        while(!queue.isEmpty())
        {
            UndirectedGraphNode cur=queue.poll();
            for(int i=0;i<cur.neighbors.size();i++)
            {
                if(!map.containsKey(cur.neighbors.get(i)))
                {
                    copy = new UndirectedGraphNode(cur.neighbors.get(i).label);
                    map.put(cur.neighbors.get(i),copy);
                    queue.offer(cur.neighbors.get(i));
                }
                map.get(cur).neighbors.add(map.get(cur.neighbors.get(i)));
            }
        }
        return map.get(node);
    }
}

深度优先：就是queue换成stack

public class Solution {
    public UndirectedGraphNode cloneGraph(UndirectedGraphNode node) {
        if(node==null) return null;
        LinkedList<UndirectedGraphNode> stack= new LinkedList<UndirectedGraphNode>();
        HashMap<UndirectedGraphNode, UndirectedGraphNode> map= new HashMap<UndirectedGraphNode, UndirectedGraphNode>();
        UndirectedGraphNode copy= new UndirectedGraphNode(node.label);
        map.put(node, copy);
        stack.push(node);
        while(!stack.isEmpty())
        {
            UndirectedGraphNode cur=stack.pop();
            for(int i=0;i<cur.neighbors.size();i++)
            {
                if(!map.containsKey(cur.neighbors.get(i)))
                {
                    copy = new UndirectedGraphNode(cur.neighbors.get(i).label);
                    map.put(cur.neighbors.get(i),copy);
                    stack.push(cur.neighbors.get(i));
                }
                map.get(cur).neighbors.add(map.get(cur.neighbors.get(i)));
            }
        }
        return map.get(node);
    }
}

深度优先-递归：把 for循环提出来

public class Solution {
    public UndirectedGraphNode cloneGraph(UndirectedGraphNode node) {
        if(node==null) return null;
        LinkedList<UndirectedGraphNode> stack= new LinkedList<UndirectedGraphNode>();
        HashMap<UndirectedGraphNode, UndirectedGraphNode> map= new HashMap<UndirectedGraphNode, UndirectedGraphNode>();
        UndirectedGraphNode copy= new UndirectedGraphNode(node.label);
        map.put(node, copy);
        help(node, map);
        return copy;
    }
    private void help(UndirectedGraphNode node, HashMap<UndirectedGraphNode, UndirectedGraphNode> map)
    {
            for(int i=0;i<node.neighbors.size();i++)
            {
                UndirectedGraphNode cur=node.neighbors.get(i);
                if(!map.containsKey(cur))
                {
                    UndirectedGraphNode copy = new UndirectedGraphNode(cur.label);
                    map.put(cur,copy);
                    help(cur, map);
                }
                map.get(node).neighbors.add(map.get(cur));
            }
    }
}