---
title: '684. Redundant Connection'
description: In this problem, a tree is an undirected graph that is connected and has no cycles
icon: dot
topics:
  - { name: "Depth-First Search", slug: "depth-first-search" }
  - { name: "Breadth-First Search", slug: "breadth-first-search" }
  - { name: "Union-Find", slug: "union-find" }
  - { name: "Graph Theory", slug: "graph" }
issue: "https://github.com/prdlk/leetcode/issues/146"
sidebar:
  label: 'Redundant Connection'
  badge: 'Medium'
---

### Example 1:
- Input: `edges = [[1,2],[1,3],[2,3]]`
- Output: `[2,3]`

### Example 2:
- Input: `edges = [[1,2],[2,3],[3,4],[1,4],[1,5]]`
- Output: `[1,4]`

### Constraints:

- `n == edges.length`
- `3 <= n <= 1000`
- `edges[i].length == 2`
- `1 <= ai < bi <= edges.length`
- `ai != bi`
- There are no repeated edges.
- The given graph is connected.

## Solution

```py
class Solution:
    def findRedundantConnection(self, edges: list[list[int]]) -> list[int]:
        N = len(edges)
        par = [i for i in range(N + 1)]
        rank = [1] * (N + 1)

        def find(n):
            if n != par[n]:
                par[n] = find(par[n])
            return par[n]

        def union(n1, n2):
            p1, p2 = find(n1), find(n2)
            if p1 == p2:
                return False

            if rank[p1] > rank[p2]:
                par[p2] = p1
                rank[p1] += rank[p2]
            else:
                par[p1] = p2
                rank[p2] += rank[p1]

            return True

        for n1, n2 in edges:
            if not union(n1, n2):
                return [n1, n2]
```