Algorithm __ Algorithm of Leetcode 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 is 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:

       1
      /\
     /   \
    0---2
         /\
         \_/

This problem is similar to the list copy: http://fisherlei.blogspot.com/2013/11/leetcode-copy-list-with-random-pointer.html

The difference is that, in a linked list copy, there is no extra space to copy, link, and split through multiple linked lists.

The copy of this map can also be inserted into the copy node through many times, linking the copy node and splitting the copy node. But the same problem is that you need to iterate through the graphs multiple times. If you want to complete the copy in a single traversal, you need to use additional memory to store the correspondence between the source node and the copy node using the map. With this relationship, in the process of traversing the graph, you can simultaneously process the access node and access the node's copy node, once completed. See the code below for details.

Undirectedgraphnode *clonegraph (Undirectedgraphnode *node) {if (node = = NULL) return null;
    Unordered_map<undirectedgraphnode *, Undirectedgraphnode *>nodemap;
    Queue<undirectedgraphnode *> visit;
    Visit.push (node);
    Undirectedgraphnode * nodeCopy = new Undirectedgraphnode (Node->label);
    Nodemap[node] = nodeCopy;
        while (Visit.size () >0) {Undirectedgraphnode * cur = visit.front ();
        Visit.pop ();
            for (int i=0; i<cur->neighbors.size (); i++) {Undirectedgraphnode *NEIGHB = cur->neighbors[i]; if (Nodemap.find (NEIGHB) = = Nodemap.end ()) {Undirectedgraphnode *neighcopy = new Undirectedgraphnode (NE
                Ighb->label);
                Nodemap[cur]->neighbors.push_back (neighcopy);
                NODEMAP[NEIGHB] = neighcopy;
            Visit.push (NEIGHB);
            }else{Nodemap[cur]->neighbors.push_back (NODEMAP[NEIGHB]); }}} return NodeCopy; }