一天一大 lee(冗余连接 II)难度:困难-Day20200917

题目:[1]

在本问题中，有根树指满足以下条件的有向图。该树只有一个根节点，所有其他节点都是该根节点的后继。每一个节点只有一个父节点，除了根节点没有父节点。

输入一个有向图，该图由一个有着 N 个节点 (节点值不重复 1, 2, ..., N) 的树及一条附加的边构成。附加的边的两个顶点包含在 1 到 N 中间，这条附加的边不属于树中已存在的边。

结果图是一个以边组成的二维数组。每一个边的元素是一对 [u, v]，用以表示有向图中连接顶点 u 和顶点 v 的边，其中 u 是 v 的一个父节点。

返回一条能删除的边，使得剩下的图是有 N 个节点的有根树。若有多个答案，返回最后出现在给定二维数组的答案。

示例：

示例 1：

输入: [[1,2], [1,3], [2,3]]
输出: [2,3]
解释: 给定的有向图如下:
  1
 / 
v   v
2-->3

示例 2：

输入: [[1,2], [2,3], [3,4], [4,1], [1,5]]
输出: [4,1]
解释: 给定的有向图如下:
5 <- 1 -> 2
     ^    |
     |    v
     4 <- 3

注意：

二维数组大小的在 3 到 1000 范围内
二维数组中的每个整数在 1 到 N 之间，其中 N 是二维数组的大小。

抛砖引玉

简化下题目：

每个节点都只有一个父节点(除根节点)的有向图叫做有根树，

给一个有根树增加一个多余的连接，找出当前这个有多余连接的有根树中最后出现的多余连接(不一定是添加的那个连接)

思路

添加多余连接造成的影响：

有根树没有了根节点(没有节点是无父节点的)
有根树中存在元素有多个父节点

那么问题就转换成了：

如果每个节点都有父节点(即有向图形成了环)那怎么找出环内的多余连接？
有元素有多个父节点时，那个父节点是最后出现的？

并查集

判断有向图是否形成了环，可以通过并查集来判断：

简要逻辑：

声明一个数组，在对应的索引为存在当前索引节点在有向图中的根节点
指定两个节点，如果在数组中其所在的索引位置的根节点相同则说明，这两个节点是组成环的节点

  1
 / 
v   v
2——>3

Disjoint:
[-1,1, 1, 1]
 0  1  2  3

具体的并查集的逻辑可以查看 B 站上其他大神的视频讲解，留下链接：

并查集[2]

回到本题：

遍历有向图可能存在的环节点的位置，如果有环，则返回包含最后一个记录的环节点的连接
遍历有向图记录每个节点的父节点，如果某个节点存在不止一个父节点，则记录这个出现多余父节点的连接位置

/**
 * @param {number[][]} edges
 * @return {number[]}
 */
var findRedundantDirectedConnection = function(edges) {
  let len = edges.length,
    uf = Array(len + 1).fill(-1),
    rank = Array(len + 1).fill(0),
    parent = Array(len + 1).fill(-1),
    // 出现多余父节点的连接位置
    repeatParent = -1,
    // 记录成环连接的索引
    cycleIndex = -1

  // 查询根节点
  function find_root(index) {
    let root = index
    while (uf[root] != -1) {
      root = uf[root]
    }
    return root
  }

  // 有向图节点不在同一根节点下则合并成一个整体
  function union_vertices(x, y, uf) {
    let x_root = find_root(x),
      y_root = find_root(y)
    if (rank[x_root] > rank[y_root]) {
      uf[y_root] = x_root
    } else if (rank[x_root] < rank[y_root]) {
      uf[x_root] = y_root
    } else {
      uf[y_root] = x_root
      rank[y_root]++
    }
  }
  // 遍历有向图
  for (let i = 0; i < len; ++i) {
    let [x, y] = edges[i]
    if (parent[y] != -1) {
      // 出现多余父节点的连接位置
      repeatParent = i
    } else {
      parent[y] = x
      if (find_root(x) == find_root(y)) {
        // 成环的边的索引
        cycleIndex = i
      } else {
        // 带层级合并（减少后续查询根节点的步数）
        union_vertices(x, y, uf)
        // 直接合并
        // uf[find_root(x)] = find_root(y)
      }
    }
  }

  // 如果没有多余父节点直接返回最后成环的连接
  if (repeatParent == -1) {
    return edges[cycleIndex]
  } else {
    // 如果有多余父节点：
    // 1.没有形成环直接返回多余父节点的连接边；
    // 2.还形成了环(第一次填充的父节点在环内)，则返回环内有多余父节点的边
    let [x, y] = edges[repeatParent]
    if (cycleIndex !== -1) {
      return [parent[y], y]
    } else {
      return [x, y]
    }
  }
}