Number of Operations to Make Network Connected

Number of Operations to Make Network Connected - Problem

Imagine you're a network administrator managing n computers numbered from 0 to n-1. These computers are connected by ethernet cables represented by the array connections, where connections[i] = [ai, bi] means computers ai and bi are directly connected.

Currently, any computer can reach any other computer either directly or through a series of connections. However, your network might be fragmented into separate groups that cannot communicate with each other.

Your mission: You can unplug cables between directly connected computers and reconnect them between any pair of disconnected computers. Find the minimum number of cable relocations needed to ensure all computers are connected in one unified network.

If it's impossible to connect all computers (not enough cables), return -1.

Input & Output

example_1.py — Basic Case

$ Input: n = 4, connections = [[0,1],[0,2],[1,2]]

› Output: 1

💡 Note: We have 4 computers with 3 connections forming one component [0,1,2] and one isolated computer [3]. Since we have 3 edges but only need 3 edges minimum for 4 computers, we can remove one redundant edge (like [1,2] since [0,1] and [0,2] already connect them) and use it to connect computer 3. Result: 1 operation.

example_2.py — Multiple Components

$ Input: n = 6, connections = [[0,1],[0,2],[0,3],[1,2]]

› Output: 2

💡 Note: We have 6 computers with connections forming one component [0,1,2,3] and two isolated computers [4] and [5]. We have 4 edges but need minimum 5 edges for 6 computers. Since we only have 4 edges, we can't connect all computers. Wait - we do have enough! We have 3 components total, so need 3-1=2 moves to connect them all.

example_3.py — Impossible Case

$ Input: n = 6, connections = [[0,1],[0,2],[0,3],[1,2],[1,3]]

› Output: 2

💡 Note: We have 6 computers forming components [0,1,2,3], [4], and [5]. That's 3 components, so we need 3-1=2 operations to connect them. We have 5 connections which is ≥ 6-1=5 minimum needed, so it's possible.

Visualization

Tap to expand

Understanding the Visualization

Count Buildings

Each connected group of computers represents one building

Check Cable Supply

Need at least n-1 cables total to connect n computers

Calculate Moves

To connect k buildings, need exactly k-1 inter-building cables

Rearrange Cables

Move redundant intra-building cables to connect buildings

Key Takeaway

🎯 Key Insight: To connect k separate components, you need exactly k-1 connections. Any extra cables can be relocated!

Time & Space Complexity

Time Complexity

⏱️

O(E × α(n))

E edges × inverse Ackermann function (nearly constant)

✓ Linear Growth

Space Complexity

O(n)

Parent and rank arrays for Union-Find structure

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 10⁵
1 ≤ connections.length ≤ min(n*(n-1)/2, 10⁵)
connections[i].length == 2
0 ≤ a_i, b_i < n
a_i ≠ b_i
No repeated connections

Asked in

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

The optimal solution uses Union-Find data structure to efficiently count connected components in O(E×α(n)) time. The key insight is that to connect k separate components, we need exactly k-1 cables. If we have at least n-1 total cables, we can always rearrange them to connect all computers.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force DFS/BFS	O(V + E)	O(V + E)	Use DFS/BFS to find all connected components and count redundant edges manually
Union-Find (Optimal)	O(E × α(n))	O(n)	Use Union-Find to efficiently group components and count redundant edges in one pass

Brute Force DFS/BFS — Algorithm Steps

Build adjacency list from connections
Use DFS/BFS to find all connected components
Count total components and total edges
Check if edges >= n-1 (minimum needed for connectivity)
Return components-1 if possible, -1 otherwise

Visualization

Tap to expand

Step-by-Step Walkthrough

Start DFS from node 0

Begin DFS traversal from first unvisited node

Mark connected nodes

All reachable nodes form one component

Find next unvisited

Start new DFS from next unvisited node

Count components

Total components found determines cables needed

Code -

solution.c — C

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

void dfs(int** graph, int* graphSize, bool* visited, int node) {
    visited[node] = true;
    for (int i = 0; i < graphSize[node]; i++) {
        if (!visited[graph[node][i]]) {
            dfs(graph, graphSize, visited, graph[node][i]);
        }
    }
}

int makeConnected(int n, int** connections, int connectionsSize, int* connectionsColSize) {
    if (connectionsSize < n - 1) {
        return -1;
    }
    
    // Build adjacency list
    int** graph = (int**)malloc(n * sizeof(int*));
    int* graphSize = (int*)calloc(n, sizeof(int));
    
    for (int i = 0; i < n; i++) {
        graph[i] = (int*)malloc(connectionsSize * 2 * sizeof(int));
    }
    
    for (int i = 0; i < connectionsSize; i++) {
        int a = connections[i][0], b = connections[i][1];
        graph[a][graphSize[a]++] = b;
        graph[b][graphSize[b]++] = a;
    }
    
    bool* visited = (bool*)calloc(n, sizeof(bool));
    int components = 0;
    
    for (int i = 0; i < n; i++) {
        if (!visited[i]) {
            dfs(graph, graphSize, visited, i);
            components++;
        }
    }
    
    // Free memory
    for (int i = 0; i < n; i++) {
        free(graph[i]);
    }
    free(graph);
    free(graphSize);
    free(visited);
    
    return components - 1;
}

Time & Space Complexity

Time Complexity

⏱️

O(V + E)

V vertices for DFS traversal + E edges to build adjacency list

✓ Linear Growth

Space Complexity

O(V + E)

Adjacency list storage + recursion stack for DFS

✓ Linear Space

Constraints

1 ≤ n ≤ 10⁵
1 ≤ connections.length ≤ min(n*(n-1)/2, 10⁵)
connections[i].length == 2
0 ≤ a_i, b_i < n
a_i ≠ b_i
No repeated connections

42.4K Views

High Frequency

~15 min Avg. Time

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

Brute Force DFS/BFS — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler