Redundant Connection - Practice Coding Problems

Redundant Connection - Problem

Redundant Connection - Find the Cycle-Creating Edge

Imagine you have a perfect tree structure with n nodes, where every node is connected and there are no cycles. Now, someone adds exactly one extra edge that creates a cycle, breaking the tree property.

Your mission: Given an array edges representing this corrupted graph, find which edge should be removed to restore the original tree structure. The graph has n nodes labeled from 1 to n, and edges[i] = [a_i, b_i] represents an undirected edge between nodes a_i and b_i.

Important: If multiple edges could be removed, return the one that appears last in the input array.

Example: If edges = [[1,2],[1,3],[2,3]], removing [2,3] leaves us with a valid tree.

Input & Output

example_1.py — Simple Triangle

$ Input: edges = [[1,2],[1,3],[2,3]]

› Output: [2,3]

💡 Note: The graph forms a triangle. Removing edge [2,3] leaves a valid tree with edges [1,2] and [1,3], where node 1 is the root connecting to nodes 2 and 3.

example_2.py — Linear with Extra Edge

$ Input: edges = [[1,2],[2,3],[3,4],[1,4],[1,5]]

› Output: [1,4]

💡 Note: The cycle is formed by nodes 1→2→3→4→1. The edge [1,4] appears later in the input than other cycle-forming edges, so it's the redundant connection to remove.

example_3.py — Minimum Case

$ Input: edges = [[1,2],[1,2]]

› Output: [1,2]

💡 Note: Two identical edges between the same nodes. The second occurrence [1,2] is redundant and should be removed.

Visualization

Tap to expand

Understanding the Visualization

Start Investigation

Begin with separate family groups (each person is their own group initially)

Process Relationships

For each relationship, check if the people are already related through other connections

Detect Impossible Loop

The first relationship that connects already-related people creates an impossible loop

Remove Redundant Connection

This impossible relationship is the redundant edge that must be removed

Key Takeaway

🎯 Key Insight: Use Union-Find to efficiently track family groups. The first relationship that connects already-related people is the redundant edge!

Time & Space Complexity

Time Complexity

⏱️

O(n⍺(n))

Where ⍺(n) is the inverse Ackermann function, practically constant for all realistic inputs

✓ Linear Growth

Space Complexity

O(n)

Space for Union-Find parent and rank arrays

⚡ Linearithmic Space

Constraints

n == edges.length
3 ≤ n ≤ 1000
edges[i].length == 2
1 ≤ a_i < b_i ≤ edges.length
No duplicate edges in the input
The given graph is connected

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal solution uses Union-Find (Disjoint Set Union) data structure to efficiently detect cycle creation. As we process edges sequentially, the moment we encounter an edge that connects two already-connected components, we've found our redundant connection. This approach runs in O(n⍺(n)) time, which is nearly linear for all practical purposes.

Common Approaches

Approach	Time	Space	Notes
✓ Union-Find (Optimal)	O(n⍺(n))	O(n)	Use Union-Find to detect the first edge that creates a cycle

Union-Find (Optimal) — Algorithm Steps

Initialize Union-Find with each node as its own parent
For each edge [u, v], find the root parents of u and v
If they have the same root, they're already connected - this edge is redundant
Otherwise, union the two components and continue
Return the first edge that connects already-connected components

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Components

Each node starts as its own connected component

Process Edge [1,2]

Union nodes 1 and 2 - they form one component

Process Edge [1,3]

Union nodes 1 and 3 - now all three nodes are connected

Process Edge [2,3]

Nodes 2 and 3 already connected through 1 - this creates a cycle!

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

int parent[1001];
int rank_arr[1001];

int find(int x) {
    if (parent[x] == 0) {
        parent[x] = x;
        rank_arr[x] = 0;
        return x;
    }
    
    if (parent[x] != x) {
        parent[x] = find(parent[x]); // Path compression
    }
    return parent[x];
}

int unite(int x, int y) {
    int px = find(x), py = find(y);
    
    if (px == py) {
        return 0; // Already connected
    }
    
    // Union by rank
    if (rank_arr[px] < rank_arr[py]) {
        parent[px] = py;
    } else if (rank_arr[px] > rank_arr[py]) {
        parent[py] = px;
    } else {
        parent[py] = px;
        rank_arr[px]++;
    }
    
    return 1;
}

int* findRedundantConnection(int** edges, int edgesSize, int* edgesColSize, int* returnSize) {
    *returnSize = 2;
    int* result = (int*)malloc(2 * sizeof(int));
    
    // Initialize
    for (int i = 0; i <= 1000; i++) {
        parent[i] = 0;
        rank_arr[i] = 0;
    }
    
    for (int i = 0; i < edgesSize; i++) {
        int u = edges[i][0], v = edges[i][1];
        if (!unite(u, v)) {
            result[0] = u;
            result[1] = v;
            return result;
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n⍺(n))

Where ⍺(n) is the inverse Ackermann function, practically constant for all realistic inputs

✓ Linear Growth

Space Complexity

O(n)

Space for Union-Find parent and rank arrays

⚡ Linearithmic Space

Constraints

n == edges.length
3 ≤ n ≤ 1000
edges[i].length == 2
1 ≤ a_i < b_i ≤ edges.length
No duplicate edges in the input
The given graph is connected

67.5K Views

High Frequency

~18 min Avg. Time

2.9K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Union-Find (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler