题目大意:
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 node0
to both nodes1
and2
. - Second node is labeled as
1
. Connect node1
to node2
. - Third node is labeled as
2
. Connect node2
to node2
(itself), thus forming a self-cycle.
Visually, the graph looks like the following:
1 / \ / \ 0 --- 2 / \ \_/意思就是:
给定一个图, 复制图.
做题思路:
用BFS搜索, 并复制. 关键就是如何用已经给定的数据结构进行BFS. 我们需要两个数据结构: 1, stack/queue进行bfs的基本数据结构; 2, unordered_map 用来保存已经复制(遍历)的节点, 同时可以查看哪些节点已经被访问过了.
代码如下:
struct UndirectedGraphNode{
int label;
vector<UndirectedGraphNode*> neighbors;
UndirectedGraphNode(int x) : label(x) {}
};
class Solution{
public:
UndirectedGraphNode* cloneGraph(UndirectedGraphNode* node){
if(!node){
return NULL;
}
UndirectedGraphNode* first = new UndirectedGraphNode(node->label);
typedef unordered_map<int, UndirectedGraphNode*> MAP;
MAP storage;
storage.insert(make_pair(first->label, first));
//stack<UndirectedGraphNode*> gstack;
queue<UndirectedGraphNode*> gstack;
gstack.push(node);
while(!gstack.empty()){
//UndirectedGraphNode *temp = gstack.top(), *newNode;
UndirectedGraphNode *temp = gstack.front(), *newNode;
if(storage.count(temp->label) == 0){
newNode = new UndirectedGraphNode(temp->label);
storage.insert(make_pair(temp->label, newNode));
}
else{
newNode = storage[temp->label];
}
gstack.pop();
for(int i=0;i<temp->neighbors.size();i++){
if(storage.count(temp->neighbors[i]->label) == 0){
storage.insert(make_pair(temp->neighbors[i]->label, new UndirectedGraphNode(temp->neighbors[i]->label)));
gstack.push(temp->neighbors[i]);
}
newNode->neighbors.push_back(storage[temp->neighbors[i]->label]);
}
}
return first;
}
};