leetcode 685 冗余链接

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

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

结果图是一个以边组成的二维数组。 每一个边 的元素是一对 [u, v]，用以表示有向图中连接顶点 u and 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 是二维数组的大小。

 

解答思路：

首先从题意中知道整幅图是由一棵有根树和一条特殊边组成，有根树的特点是子节点只有一个父节点，并且也没有环，又只有一条特殊边可知，节点的入度最大为2，也只有一个环。

那么就只会出现三种情况

第一种：无环，但是有结点入度为2的结点（结点3）

[[1,2], [1,3], [2,3]]

  1
 / \
v   v
2-->3

 

第二种：有环，没有入度为2的结点

[[1,2], [2,3], [3,4], [4,1], [1,5]]

5 <- 1 -> 2
     ^    |
     |    v
     4 <- 3

 

第三种：有环，且有入度为2的结点（结点1）

[[1,2],[2,3],[3,1],[1,4]]

     4
    /
   v
   1
 /  ^
v    \
2 -->3

 

对于这三种情况的处理方法各不相同，首先对于第一种情况，我们返回的产生入度为2的后加入的那条边[2, 3]，而对于第二种情况，我们返回的是刚好组成环的最后加入的那条边[4, 1]，最后对于第三种情况我们返回的是组成环，且组成入度为2的那条边[3, 1]。

所以先检测哪个顶点入度为2，接下来的问题就是删除哪一条入边，可以假设删其中一条，将那条边的子节点置0。然后看看是否还构成环，如果不构成，说明删的边是对的；如果还构成环，说明应该删另一条入边。

如果没有顶点入度为2，那么应该删除最后一条导致环的边。

有向图中如何判断环的存在：通过判断图中是否有这样的两个顶点，这两个顶点的最远祖先是否相同，如果相同，则说明有存在环；

class Solution {
public:
    vector<int> findRedundantDirectedConnection(vector<vector<int>>& edges) 
    {
        int len = edges.size() ;
        vector<int> root(len + 1 , -1) , first , second;
        
        for(auto& edge : edges)
        {
            if(root[edge[1]] == -1)
            {
                root[edge[1]] = edge[0] ;
            }
            else
            {
                first = { root[edge[1]] , edge[1] } ;
                second = edge ;
                edge[1] = 0 ;
                
            }
        }
        
        for(int i = 0 ; i < root.size() ; i++) root[i] = i ; //
        
        for(auto edge : edges)
        {
            if(edge[1] == 0) continue ;
            int x = find(root , edge[0]) , y = find(root , edge[1]) ; 
            if(x == y) return first.empty() ? edge : first ;
            root[edge[1]] = edge[0] ;
        }
        return second ;
    }
    
    int find(vector<int> root , int k)
    {
        return k == root[k] ? k : find(root , root[k]) ;
    }
};

解题思路二 :

从题目可知有三种情况 : ① 只存在一个顶点入度为2 , 无环 ; ②只存在环 , 不存在入度为2的顶点 ; ③既存在入度为2的顶点,又存在环 ; 如果存在入度为2的顶点,那么有且只有一个顶点入度为2 , 找出两条相应的入边 , 一条先出现为first , 另一条后出现为second , 因为题目要求如果有多种可能,返回最后一条边 ; 

所以遍历每一条边,如果second存在,则不遍历 ;

if(!second.empty() && edge == second) continue ;

unionFind可以判断两个点是否存在至少两条的连接路径 , 当某一条的边的两个顶点有共同的祖先时 , 说明这两个顶点存在至少两条的连接路径,那么如果first存在的话,first一定是多余的连接 ; 如果不存在那么该边一定是多余的连接 ; 

ps:为什么先跳过second的遍历呢?因为题目要求当有多条边满足时,返回最后一条边 , 而当跳过first的遍历使得图中无环时只能说明first可以当作一条冗余的连接,而不能说明second不是一条冗余的连接 ; 如果second是的话,返回first就不合题意了 ; 所以要先确定second是否是一条冗余的连接,如果是,则返回second ;

class Solution {
public:
    vector<int> findRedundantDirectedConnection(vector<vector<int>>& edges) 
    {
        int N = edges.size() ;
        vector<vector<int>> parents(N + 1) ;
        vector<int> first , second ;
        
        for(auto edge : edges)
        {
            parents[edge[1]].push_back(edge[0]) ;
            if(parents[edge[1]].size() == 2) 
            {
                first = {parents[edge[1]][0] , edge[1]} ;
                second = {parents[edge[1]][1] , edge[1]} ;
                break ;
            }
        }
        
        root = vector<int>(N + 1 , 0) ;
        for(int i = 1 ; i <= N ; i++) root[i] = i ;
        
        for(auto edge : edges)
        {
          
            if(!second.empty() && edge == second) continue ;
            if(unionFind(edge[0] , edge[1])) 
            {
                if(!first.empty()) return first ;
                else return edge ;
            }
        }
        
        return second ;
    }
    
    int find(int x)
    {
        return x == root[x] ? x : find(root[x]) ; 
    }
    
    bool unionFind(int p , int c)
    {
        int x = find(p) , y = find(c) ;
        
        if(x == y) return true ;
        
        root[c] = x ;
        
        return false ;
    }
    
private:
    
    vector<int> root ;
};