Redundant Connection

Redundant Connection - Problem

In this problem, a tree is an undirected graph that is connected and has no cycles.

You are given a graph that started as a tree with n nodes labeled from 1 to n, with one additional edge added. The added edge has two different vertices chosen from 1 to n, and was not an edge that already existed.

The graph is represented as an array edges of length n where edges[i] = [a_i, b_i] indicates that there is an edge between nodes a_i and b_i in the graph.

Return an edge that can be removed so that the resulting graph is a tree of n nodes. If there are multiple answers, return the answer that occurs last in the input.

Input & Output

Example 1 — Basic Triangle

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

› Output: [2,3]

💡 Note: We have nodes 1,2,3. Edges [1,2] and [1,3] form a valid tree. Adding [2,3] creates a cycle 1-2-3-1, so [2,3] is redundant.

Example 2 — Square with Diagonal

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

› Output: [1,4]

💡 Note: Path 1-2-3-4 already connects nodes 1 and 4. Edge [1,4] creates cycle and occurs last among cycle-creating edges.

Example 3 — Linear with Back Edge

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

› Output: [1,3]

💡 Note: Edges [1,2] and [2,3] form path 1-2-3. Adding [1,3] creates cycle 1-2-3-1, and [1,3] is the last edge.

Constraints

3 ≤ edges.length ≤ 1000
edges[i].length == 2
1 ≤ a_i < b_i ≤ edges.length

Visualization

Tap to expand

Asked in

a Amazon 15 G Google 12 f Facebook 8 M Microsoft 6

The key insight is to detect when adding an edge would create a cycle. The Union-Find approach is optimal, tracking connected components efficiently. When two nodes are already in the same component, their connecting edge is redundant. Time: O(n⋅α(n)), Space: O(n).

Common Approaches

✓ Brute Force - Try Removing Each Edge

⏱️ Time: O(n³) Space: O(n)

For each edge, remove it temporarily and check if the remaining graph is connected and has no cycles. The last edge that makes the graph valid when removed is our answer.

DFS Cycle Detection

⏱️ Time: O(n²) Space: O(n)

Build the graph incrementally and use DFS to detect when adding an edge creates a cycle. The edge that creates the cycle is redundant.

Union-Find (Disjoint Set)

⏱️ Time: O(n⋅α(n)) Space: O(n)

Process edges one by one using Union-Find data structure. When we encounter an edge connecting two nodes that are already in the same component, that edge is redundant.

Brute Force - Try Removing Each Edge — Algorithm Steps

Step 1: For each edge in reverse order
Step 2: Remove the edge temporarily
Step 3: Check if remaining graph is a valid tree
Step 4: Return the first edge that works

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with Graph

Original graph with cycle

Try Removing Edge

Test each edge removal from last to first

Check Validity

Use DFS to verify remaining graph is connected tree

Code -

solution.c — C

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

// Global variables for DFS
int adj[1001][1001];
int visited[1001];
int n;

void dfs(int node) {
    visited[node] = 1;
    for (int i = 1; i <= n; i++) {
        if (adj[node][i] && !visited[i]) {
            dfs(i);
        }
    }
}

int isValidTree(int** edges, int edgesSize, int skipIndex) {
    // Clear adjacency matrix
    memset(adj, 0, sizeof(adj));
    
    // Build adjacency matrix (skip the edge at skipIndex)
    for (int i = 0; i < edgesSize; i++) {
        if (i == skipIndex) continue;
        int u = edges[i][0];
        int v = edges[i][1];
        adj[u][v] = adj[v][u] = 1;
    }
    
    // DFS to check connectivity
    memset(visited, 0, sizeof(visited));
    dfs(1);
    
    // Count visited nodes
    int count = 0;
    for (int i = 1; i <= n; i++) {
        if (visited[i]) count++;
    }
    
    return count == n;
}

int* solution(int** edges, int edgesSize, int* returnSize) {
    *returnSize = 2;
    n = edgesSize; // Number of nodes equals number of edges in this problem
    
    // Try removing each edge from last to first
    for (int i = edgesSize - 1; i >= 0; i--) {
        if (isValidTree(edges, edgesSize, i)) {
            int* result = (int*)malloc(2 * sizeof(int));
            result[0] = edges[i][0];
            result[1] = edges[i][1];
            return result;
        }
    }
    
    // Fallback (should not reach here)
    int* result = (int*)malloc(2 * sizeof(int));
    result[0] = edges[edgesSize - 1][0];
    result[1] = edges[edgesSize - 1][1];
    return result;
}

// Helper function to parse JSON array
int parseEdges(char* input, int*** edges, int* edgesSize) {
    int capacity = 10;
    *edges = (int**)malloc(capacity * sizeof(int*));
    *edgesSize = 0;
    
    char* p = input;
    while (*p && *p != '[') p++;
    if (!*p) return 0;
    p++; // skip first '['
    
    while (*p) {
        // Skip whitespace
        while (*p && isspace(*p)) p++;
        if (*p == ']') break;
        
        // Find inner array
        if (*p == '[') {
            p++; // skip '['
            int a, b;
            if (sscanf(p, "%d,%d", &a, &b) == 2) {
                if (*edgesSize >= capacity) {
                    capacity *= 2;
                    *edges = (int**)realloc(*edges, capacity * sizeof(int*));
                }
                (*edges)[*edgesSize] = (int*)malloc(2 * sizeof(int));
                (*edges)[*edgesSize][0] = a;
                (*edges)[*edgesSize][1] = b;
                (*edgesSize)++;
            }
            // Skip to closing bracket
            while (*p && *p != ']') p++;
            if (*p == ']') p++;
        }
        
        // Skip comma
        while (*p && (*p == ',' || isspace(*p))) p++;
    }
    
    return 1;
}

int main() {
    char input[10000];
    if (fgets(input, sizeof(input), stdin) == NULL) {
        return 1;
    }
    
    int** edges;
    int edgesSize;
    
    if (!parseEdges(input, &edges, &edgesSize)) {
        fprintf(stderr, "Failed to parse input\n");
        return 1;
    }
    
    int returnSize;
    int* result = solution(edges, edgesSize, &returnSize);
    printf("[%d,%d]\n", result[0], result[1]);
    
    // Cleanup
    free(result);
    for (int i = 0; i < edgesSize; i++) {
        free(edges[i]);
    }
    free(edges);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

For each of n edges, we run DFS on n nodes to check connectivity

✓ Linear Growth

Space Complexity

O(n)

Space for adjacency list and visited array during DFS

⚡ Linearithmic Space

180.0K Views

Medium Frequency

~15 min Avg. Time

4.2K 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try Removing Each Edge — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler