BFS解法

思路：
问题就是求在环中的节点，
考虑拓扑排序，显然环节点的度一定永远大于1，而其他所有节点都可以通过bfs拓扑排序消减直到小于等于1。
拓扑排序过程中记录不是环的节点，最后在edges数组中判断最后出现的环节点。

代码

class Solution {
    List<List<Integer>> edges=new ArrayList<>();
    int[]degree;
    public int[] findRedundantConnection(int[][] e) {
        int n=e.length;
        degree=new int[n];
        Set<Integer> nonCycle=new HashSet<>();
        Deque<Integer> dq=new LinkedList<>();
        for(int i=0;i<n;i++){
            edges.add(new ArrayList<>());
        }
        for(int []i:e){//构造邻接表和度
            edges.get(i[0]-1).add(i[1]-1);
            edges.get(i[1]-1).add(i[0]-1);
            degree[i[0]-1]++;
            degree[i[1]-1]++;
        }
        for(int i=0;i<n;i++){
            if(degree[i]==1){
                dq.offer(i);
                nonCycle.add(i+1);
            }
        }
        while(!dq.isEmpty()){
            int len=dq.size();
            for(int i=0;i<len;i++){
                int u=dq.poll();
                for(int v:edges.get(u)){
                    degree[v]--;
                    if(degree[v]==1){
                        dq.offer(v);
                        nonCycle.add(v+1);
                    }
                }
            }
        }
        int[] res=new int[2];
        for(int[]i:e){
            if(!nonCycle.contains(i[0])&&!nonCycle.contains(i[1])){
                res[0]=i[0];
                res[1]=i[1];
            }
        }
        return res;
    }
}

DFS解法

思路：stack记录搜索过程中的路径，如果发现当前访问的结点已经stack中且不等于stack最后一个元素，则找到了环。

代码

class Solution:
    def findRedundantConnection(self, edges: List[List[int]]) -> List[int]:
        def DFS(i):
            if i in stack:
                if i!=stack[-2]:
                    index=stack.index(i)
                    self.result=stack[index:]
                    return True
                else:
                    return False
            stack.append(i)
            for v in graph[i]:
                if DFS(v):
                    return True
            stack.pop()
        nodenum=len(edges)
        graph=[[] for _ in range(nodenum+1)]
        for i,j in edges:
            graph[i].append(j)
            graph[j].append(i)
        stack=[]
        DFS(1)
        circle=set()
        length=len(self.result)
        for i in range(length):
            circle.add((self.result[i],self.result[(i+1)%length]))
        for edge in edges[::-1]:
            if (edge[0],edge[1]) in circle or (edge[1],edge[0]) in circle:
                return edge

并查集解法

思路:

在一棵树中，边的数量比节点的数量少 11。如果一棵树有 nn 个节点，则这棵树有 n-1n−1 条边。这道题中的图在树的基础上多了一条附加的边，因此边的数量也是 nn。

树是一个连通且无环的无向图，在树中多了一条附加的边之后就会出现环，因此附加的边即为导致环出现的边。

可以通过并查集寻找附加的边。初始时，每个节点都属于不同的连通分量。遍历每一条边，判断这条边连接的两个顶点是否属于相同的连通分量。

如果两个顶点属于不同的连通分量，则说明在遍历到当前的边之前，这两个顶点之间不连通，因此当前的边不会导致环出现，合并这两个顶点的连通分量。
如果两个顶点属于相同的连通分量，则说明在遍历到当前的边之前，这两个顶点之间已经连通，因此当前的边导致环出现，为附加的边，将当前的边作为答案返回。

代码

class Solution:
    def findRedundantConnection(self, edges: List[List[int]]) -> List[int]:
        n = len(edges)
        parent = list(range(n + 1))

        def find(index: int) -> int:
            if parent[index] != index:
                parent[index] = find(parent[index])
            return parent[index]
        
        def union(index1: int, index2: int):
            parent[find(index1)] = find(index2)

        for node1, node2 in edges:
            if find(node1) != find(node2):
                union(node1, node2)
            else:
                return [node1, node2]
        
        return []