[Leetcode] 685. Redundant Connection II 解题报告

题目：

In this problem, a rooted tree is a directed graph such that, there is exactly one node (the root) for which all other nodes are descendants of this node, plus every node has exactly one parent, except for the root node which has no parents.

The given input is a directed graph that started as a rooted tree with N nodes (with distinct values 1, 2, ..., N), with one additional directed edge added. The added edge has two different vertices chosen from 1 to N, and was not an edge that already existed.

The resulting graph is given as a 2D-array of edges. Each element of edges is a pair [u, v] that represents a directed edge connecting nodes u and v, where u is a parent of child v.

Return an edge that can be removed so that the resulting graph is a rooted tree of N nodes. If there are multiple answers, return the answer that occurs last in the given 2D-array.

Example 1:

Input: [[1,2], [1,3], [2,3]]
Output: [2,3]
Explanation: The given directed graph will be like this:
  1
 / \
v   v
2-->3

Example 2:

Input: [[1,2], [2,3], [3,4], [4,1], [1,5]]
Output: [4,1]
Explanation: The given directed graph will be like this:
5 <- 1 -> 2
     ^    |
     |    v
     4 <- 3

Note:

• The size of the input 2D-array will be between 3 and 1000.
• Every integer represented in the 2D-array will be between 1 and N, where N is the size of the input array.

  思路：

  有两种情况可能导致一棵树不合法：1）一个节点含有多于一个的父节点；2）存在环。根据题意，如果我们仅仅移除一棵父节点就可以使得树变得合法，那么说明一个节点最多含有两个父节点。因此我们的策略是：

  1）检查是否存在一个节点，其含有两个父节点。如果是，则我们分别将它们存储起来，记为A和B，并且默认置第二个边为invalid。

  2）执行union-find操作。如果当前树是合法的，则直接返回B即可；如果不存在多余的父节点，我们就可以去查找环，并且返回环上的一个边；如果上述两个条件都不满足，说明A才是导致数不合法的父节点，所以我们将A返回。

  代码：

  class Solution {
  public:
      vector<int> findRedundantDirectedConnection(vector<vector<int>>& edges) {
          int n = edges.size();
          vector<int> parent(n + 1, 0), candA, candB;
          // step 1, check whether there is a node with two parents
          for (auto &edge : edges) {
              if (parent[edge[1]] == 0) {
                  parent[edge[1]] = edge[0];
              } 
              else {
                  candA = {parent[edge[1]], edge[1]};     // former edge
                  candB = edge;                           // current edge
                  edge[1] = 0;                            // remove canB for following operations
              }
          } 
          // step 2, union find
          for (int i = 1; i <= n; ++i) {
              parent[i] = i;
          }
          for (auto &edge : edges) {
              if (edge[1] == 0) {
                  continue;
              }
              int u = edge[0], v = edge[1], pu = root(parent, u);
              // Now every node only has 1 parent, so root of v is implicitly v
              if (pu == v) {              // circle found
                  if (candA.empty()) {    // no node has two parent nodes
                      return edge;
                  }
                  return candA;           // candA makes the tree invalid
              }
              parent[v] = pu;
          }
          return candB;
      }
  private:
      int root(vector<int>& parent, int k) {
          if (parent[k] != k) {
              parent[k] = root(parent, parent[k]);
          }
          return parent[k];
      }
  };