Redundant Connection
You are given a connected undirected graph with n nodes labeled from 1 to n. Initially, it contained no cycles and consisted of n-1 edges.
We have now added one additional edge to the graph. The edge has two different vertices chosen from 1 to n, and was not an edge that previously existed in the graph.
The graph is represented as an array edges of length n where edges[i] = [ai, bi] represents an edge between nodes ai and bi in the graph.
Return an edge that can be removed so that the graph is still a connected non-cyclical graph. If there are multiple answers, return the edge that appears last in the input edges.
Example 1:
Input: edges = [[1,2],[1,3],[3,4],[2,4]]
Output: [2,4]
Example 2:
Input: edges = [[1,2],[1,3],[1,4],[3,4],[4,5]]
Output: [3,4]
Constraints:
n == edges.length
3 <= n <= 100
1 <= edges[i][0] < edges[i][1] <= edges.length
There are no repeated edges and no self-loops in the input.
Solution
If the problem does not require to return the edge that appears last in the input edges, a DFS is enough to solve this problem. If we visit a repetitive node, return the last edge we pass.
Unfortulately, we need to output the last in the input edges. A solution is Disjoint Set Union, which allows us to process the edges in input order. When a new edge is coming, we check whether the corresponding 2 vertices are already in the same set. If so, just return this edge, or we union the sets the 2 vertices belongs to.
A technique called path compression can be applied on Disjoint Set Union, which means we directly set the parent vertice of each vertice to its root vertice, saving the time of jumping along the parent path.
Code
class Solution:
def findRedundantConnection(self, edges: List[List[int]]) -> List[int]:
cluster = [i for i in range(0, len(edges)+2)]
def find(a):
if cluster[a] == a:
return a
cluster[a] = find(cluster[a])
return cluster[a]
def link(a, b):
cluster[find(b)] = find(a)
for edge in edges:
if find(edge[0]) == find(edge[1]):
return edge
link(edge[0], edge[1])
