一天一大 lee(克隆图)难度:中等-Day20200812

题目:

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

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

示例

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

测试用例格式：

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

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

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

1. 示例 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 。

2. 示例 2

输入：adjList = [[]]
输出：[[]]
解释：输入包含一个空列表。该图仅仅只有一个值为 1 的节点，它没有任何邻居。

3. 示例 4

输入：adjList = []
输出：[]
解释：这个图是空的，它不含任何节点。

4. 示例 4

输入：adjList = [[2],[1]]
输出：[[2],[1]]

提示

1. 节点数不超过 100 。
2. 每个节点值 Node.val 都是唯一的，1 <= Node.val <= 100。
3. 无向图是一个简单图，这意味着图中没有重复的边，也没有自环。
4. 由于图是无向的，如果节点 p 是节点 q 的邻居，那么节点 q 也必须是节点 p 的邻居。
5. 图是连通图，你可以从给定节点访问到所有节点。

抛砖引玉

• 遍历拷贝每个节点
• 节点的连接通过 neighbors 连接
• 则拷贝的过程为：先拷贝 val，在依次拷贝它的 neighbors
  因为这些 neighbors 还有 neighbor 则使用递归知道递归继续拷贝
• 递归的终止条件：
  • 无向图如果如示例 1 首尾相接则会遍历到已经拷贝的节点，则约到拷贝过的节点直接返回
  • 如不首尾相接则会约到 undefined,遇到 undefined 则到达终点，返回

实现

• 记录拷贝过的节点
• 可以使用哈希方法记录，注意：
  val 是个 node 节点，如果使用 val 作为 hash 需要支持 Symbol 作为 hash 的对象存贮如 map
  如果使用 object 或者 array 存储需要使用 val.val 即这个节点下的值

深度优先搜索

/**
 * // Definition for a Node.
 * function Node(val, neighbors) {
 *    this.val = val === undefined ? 0 : val;
 *    this.neighbors = neighbors === undefined ? [] : neighbors;
 * };
 */

/**
 * @param {Node} node
 * @return {Node}
 */
var cloneGraph = function (node) {
  // ----------------> map
  let map = new Map()
  function dfs(val) {
    // 遇到最后的节点
    if (!val) return undefined
    // 遇到拷贝过的节点
    if (map.get(val)) return map.get(val)
    // 新生成节点-拷贝老节点的值
    let newNode = new Node(val.val)
    // 记录
    map.set(val, newNode)
    // 遍历递归其neighbors接地那
    for (let i = 0; i < val.neighbors.length; i++) {
      newNode.neighbors.push(dfs(val.neighbors[i]))
    }
    return newNode
  }

  // -------------> Array
  // let map = []
  // function dfs(val) {
  //   if (!val) return undefined
  //   if (map[val.val]) return map[val.val]
  //   let newNode = new Node(val.val)
  //   map[val.val] = newNode
  //   for (let i = 0; i < val.neighbors.length; i++) {
  //    newNode.neighbors.push(dfs(val.neighbors[i]))
  //   }
  //   return newNode
  // }

  return dfs(node)
}

广度优先遍历

• 声明 dp 存放待拷贝节点
• 拷贝完移除，遇到待拷贝继续添加
• 知道无待拷贝节点则返回

var cloneGraph = function (node) {
  if (!node) return null
  let dp = [node],
    map = new Map(),
    newNode = new Node(node.val)

  map.set(node, newNode)
  while (dp.length) {
    // 逐个取出拷贝
    let item = dp.shift(),
      Root = map.get(item)
    // 遍历已经给拷贝的节点的neighbors，并推到neighbors数组中
    for (let i = 0; i < item.neighbors.length; i++) {
      if (!map.get(item.neighbors[i])) {
        // 如果不存在则记录待拷贝且拷贝记录到哈希map中
        dp.push(item.neighbors[i])
        map.set(item.neighbors[i], new Node(item.neighbors[i].val))
      }
      Root.neighbors.push(map.get(item.neighbors[i]))
    }
  }
  return newNode
}

博客: 小书童博客

每天的每日一题，写的题解会同步更新到公众号一天一大 lee 栏目
欢迎关注留言

公号: 坑人的小书童