Maximal Network Rank - Practice Coding Problems

Maximal Network Rank - Problem

Graph Medium

Imagine you're a city infrastructure analyst tasked with evaluating road network connectivity between cities. You have n cities connected by bidirectional roads, and you need to find the maximal network rank - a measure of how well-connected any pair of cities can be.

The network rank of two different cities is calculated as:

Count all roads directly connected to the first city
Count all roads directly connected to the second city
Add these counts together
Important: If there's a direct road between these two cities, count it only once (not twice)

Your goal is to find the maximum possible network rank among all pairs of different cities.

Input: An integer n (number of cities) and a 2D array roads where roads[i] = [ai, bi] represents a bidirectional road between cities ai and bi.

Output: Return the maximal network rank as an integer.

Input & Output

example_1.py — Python

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

› Output: 4

💡 Note: The network rank of cities 0 and 1 is 4 as there are 4 roads that are connected to either 0 or 1. Note that the road between 0 and 1 is only counted once.

example_2.py — Python

$ Input: n = 5, roads = [[0,1],[0,3],[1,2],[1,3],[2,3],[2,4]]

› Output: 5

💡 Note: There are 5 roads that are connected to cities 1 or 2.

example_3.py — Python

$ Input: n = 8, roads = [[0,1],[1,2],[2,3],[2,4],[5,6],[5,7]]

› Output: 5

💡 Note: The network rank of 2 and 5 is 5. Note that all the cities do not have to be connected.

Constraints

2 ≤ n ≤ 100
0 ≤ roads.length ≤ n * (n-1) / 2
roads[i].length == 2
0 ≤ a_i, b_i ≤ n-1
a_i != b_i
Each road connects two different cities
There are no repeated roads

Visualization

Tap to expand

Understanding the Visualization

Build Network

Create the road network between cities

Count Connections

For each city, count how many roads it has

Check Pairs

For each pair, add their road counts

Avoid Double Counting

If cities are directly connected, subtract 1

Find Maximum

Track the highest network rank found

Key Takeaway

🎯 Key Insight: We only need to store degree counts and check direct connections - no need for complex graph traversal!

Asked in

G Google 12 a Amazon 8 ⊞ Microsoft 6 f Meta 4

The optimal approach uses degree counting with adjacency set lookup. First, count the number of roads for each city and store direct connections in a set. Then check all pairs of cities, calculating their network rank as the sum of their degrees minus 1 if they're directly connected. This achieves O(n² + m) time complexity with O(n + m) space.

Common Approaches

Approach	Time	Space	Notes
✓ Degree Counting with Adjacency Set	O(n² + m)	O(n + m)	Precompute degrees and use adjacency set for efficient direct connection lookup
Brute Force (Check All Pairs)	O(n² + m)	O(n + m)	Check every pair of cities and count their combined connectivity

Degree Counting with Adjacency Set — Algorithm Steps

First pass: iterate through roads to count degree of each city
Build adjacency set for O(1) direct connection lookup
Second pass: for each pair of cities (i, j):
Calculate network rank using precomputed degrees
Check direct connection using adjacency set
Track maximum network rank

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Degrees

First pass: count roads for each city

Build Adjacency Set

Store direct connections for O(1) lookup

Check Pairs

Second pass: use precomputed data

Efficient Lookup

Use set for fast direct connection check

Code -

solution.c — C

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

int maximalNetworkRank(int n, int** roads, int roadsSize, int* roadsColSize) {
    // Use adjacency matrix for simpler implementation in C
    int** adj = (int**)malloc(n * sizeof(int*));
    int* degree = (int*)calloc(n, sizeof(int));
    
    for (int i = 0; i < n; i++) {
        adj[i] = (int*)calloc(n, sizeof(int));
    }
    
    // First pass: build adjacency matrix and compute degrees
    for (int i = 0; i < roadsSize; i++) {
        int a = roads[i][0], b = roads[i][1];
        adj[a][b] = 1;
        adj[b][a] = 1;
        degree[a]++;
        degree[b]++;
    }
    
    int maxRank = 0;
    
    // Second pass: check all pairs
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            int rank = degree[i] + degree[j];
            if (adj[i][j]) {
                rank--;
            }
            if (rank > maxRank) {
                maxRank = rank;
            }
        }
    }
    
    // Cleanup
    for (int i = 0; i < n; i++) {
        free(adj[i]);
    }
    free(adj);
    free(degree);
    
    return maxRank;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² + m)

O(m) for first pass through roads, O(n²) for checking all pairs

⚠ Quadratic Growth

Space Complexity

O(n + m)

O(n) for degree array, O(m) for adjacency set

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~15 min Avg. Time

892 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

Degree Counting with Adjacency Set — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler