133克隆图（递归深度优先搜索+哈希表）

1、题目描述

给你无向 连通 图中一个节点的引用，请你返回该图的 深拷贝（克隆）。

图中的每个节点都包含它的值 val（int） 和其邻居的列表（list[Node]）。

class Node {
    public int val;
    public List<Node> neighbors;
}

2、示例

简单起见，每个节点的值都和它的索引相同。例如，第一个节点值为 1（val = 1），第二个节点值为 2（val = 2），以此类推。该图在测试用例中使用邻接列表表示。

邻接列表 是用于表示有限图的无序列表的集合。每个列表都描述了图中节点的邻居集。

给定节点将始终是图中的第一个节点（值为 1）。你必须将 给定节点的拷贝 作为对克隆图的引用返回。

输入：adjList = [[2,4],[1,3],[2,4],[1,3]]
输出：[[2,4],[1,3],[2,4],[1,3]]
解释：
图中有 4 个节点。
节点 1 的值是 1，它有两个邻居：节点 2 和 4 。
节点 2 的值是 2，它有两个邻居：节点 1 和 3 。
节点 3 的值是 3，它有两个邻居：节点 2 和 4 。
节点 4 的值是 4，它有两个邻居：节点 1 和 3 。

3、题解

基本思想：递归深搜+HashMap，HashMap保存旧节点与新生成的节点之间映射。

这道题充分说明建立好的数据结构对解决问题事半功倍，第一个解法的想法是自己想出来的，建立的是val与node的HashMap，导致代码不够简洁，第二个解法参考别人的想法，代码相当简单易懂。

#include<iostream>
#include<algorithm>
#include<vector>
#include<unordered_map>
#include<unordered_set>
using namespace std;
class Node {
public:
	int val;
	vector<Node*> neighbors;
	Node() {
		val = 0;
		neighbors = vector<Node*>();
	}
	Node(int _val) {
		val = _val;
		neighbors = vector<Node*>();
	}
	Node(int _val, vector<Node*> _neighbors) {
		val = _val;
		neighbors = _neighbors;
	}
};
void InitGraph(Node* node, vector<int> vec)
{
	vector<Node*> graph;
	graph.push_back(node);
	for (int i = 1; i < vec.size(); i++)
	{
		Node* n = new Node(vec[i]);
		graph.push_back(n);
	}
	graph[0]->neighbors = { graph[1],graph[3] };
	graph[1]->neighbors = { graph[0],graph[2] };
	graph[2]->neighbors = { graph[1],graph[3] };
	graph[3]->neighbors = { graph[0],graph[2] };
}
class Solution {
public:
	unordered_map<Node*, bool> visited;    //标记旧图中节点是否访问过
	unordered_map<int, Node*> HashMap;    //保存生成的新节点，val和node映射
	Node* cloneGraph(Node* node) {
		//基本思想：递归+HashMap，先递归生成新节点保存在HashMap中，然后递归将生成的新节点连接起来成新图
		if (node == NULL)
			return NULL;
		//递归生成新节点保存在HashMap中
		CreateHashMap(node);
		Node* newNode = HashMap[node->val];
		//递归将生成的新节点连接起来成新图
		CloneNode(node, &newNode);
		return newNode;
	}
	void CreateHashMap(Node* node)
	{
		if (visited.find(node) == visited.end())
		{
			visited[node] = false;
			Node* temp = new Node(node->val);
			HashMap[temp->val] = temp;
		}	
		else
			return;
		for (auto i = node->neighbors.begin(); i != node->neighbors.end(); i++)
		{
			CreateHashMap(*i);
		}
	}
	void CloneNode(Node* node,Node** newNode)
	{
		if (visited[node] == false)
		{
			visited[node] = true;
			for (auto i = node->neighbors.begin(); i != node->neighbors.end(); i++)
			{
				(*newNode)->neighbors.push_back(HashMap[(*i)->val]);	
				CloneNode(*i, &HashMap[(*i)->val]);
			}
		}
	}
};
class Solution1 {
public:
	unordered_map<Node*, Node*> HashMap;    //保存旧节点与新生成的节点之间映射
	Node* cloneGraph(Node* node) {
		//优化版本：这道题充分说明建立好的数据结构对解决问题事半功倍
		//上面的想法是自己想出来的，建立的是val与node的HashMap，导致代码不够简洁，这是参考别人的想法
		if (node == NULL)
			return NULL;
		//已经生成的节点不再生成
		if (HashMap.find(node) != HashMap.end())
			return HashMap[node];
		Node* newNode = new Node(node->val);
		HashMap[node] = newNode;
		//生成与node相连接的节点
		for (auto i = node->neighbors.begin(); i != node->neighbors.end(); i++)
		{
			newNode->neighbors.push_back(cloneGraph(*i));
		}
		return newNode;
	}
};
int main()
{
	Solution1 solute;
	vector<int> vec = { 1,2,3,4 };
	Node* node = new Node(1);
	InitGraph(node, vec);
	node = solute.cloneGraph(node);
	cout << node->val << endl;
	for (auto n = node->neighbors.begin(); n != node->neighbors.end(); n++)
	{
		cout << (*n)->val << endl;
		cout << (*n)->neighbors.front()->val << endl;
		cout << (*n)->neighbors.back()->val << endl;
	}
		
	return 0;
}