Maximum Total Importance of Roads - Practice Coding Problems

Maximum Total Importance of Roads - Problem

Maximum Total Importance of Roads

Imagine you're a city planner tasked with optimizing the economic value of transportation infrastructure! You have n cities numbered from 0 to n-1, connected by bidirectional roads.

Your mission: assign each city a unique importance value from 1 to n. The importance of each road is calculated as the sum of the importance values of the two cities it connects.

Goal: Maximize the total importance of all roads by strategically assigning values to cities.

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

Output: Return the maximum possible total importance of all roads after optimal value assignment.

Input & Output

example_1.py — Basic Linear Chain

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

› Output: 43

💡 Note: Cities have degrees: [2,3,4,2,1]. Sorted by degree: [4,0,3,1,2]. Assign values [1,2,3,4,5] respectively. City degrees: 4→1, 0→2, 3→3, 1→4, 2→5. Total: (2+4)+(4+5)+(5+3)+(2+5)+(4+3)+(5+1) = 43

example_2.py — Simple Triangle

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

› Output: 12

💡 Note: All cities have degree 2, so any assignment of [1,2,3] gives the same result. Each road contributes the sum of two different values, total = (1+2)+(2+3)+(3+1) = 12

example_3.py — Star Graph

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

› Output: 16

💡 Note: City 0 has degree 3 (hub), others have degree 1. Assign highest value 4 to city 0, values [1,2,3] to others. Total = (4+1)+(4+2)+(4+3) = 16

Constraints

2 ≤ n ≤ 5 × 10⁴
1 ≤ roads.length ≤ 5 × 10⁴
roads[i].length == 2
0 ≤ a_i, b_i ≤ n - 1
a_i ≠ b_i
No duplicate roads

Visualization

Tap to expand

Understanding the Visualization

Count Flight Connections

Count how many flights each airport handles (degree of each city)

Identify Hub Airports

Sort airports by their flight volume - busiest hubs first

Assign VIP Levels

Give highest VIP levels to the busiest hubs since they affect the most flights

Calculate Network Value

Sum up the total value across all flight routes

Key Takeaway

🎯 Key Insight: Assign highest importance values to the most connected cities (highest degree) because they contribute to the most roads, maximizing total importance.

Asked in

G Google 25 a Amazon 18 f Meta 15 ⊞ Microsoft 12

The optimal solution uses a greedy strategy: count each city's degree (number of connected roads), then assign the highest importance values to cities with the most connections. This works because cities with more roads contribute to more total importance. Time complexity: O(m + n log n).

Common Approaches

Approach	Time	Space	Notes
✓ Greedy by Degree (Optimal)	O(m + n log n)	O(n)	Count each city's degree, then assign highest values to highest-degree cities
Brute Force (Try All Permutations)	O(n! × m)	O(n)	Generate all possible value assignments and find the maximum total importance

Greedy by Degree (Optimal) — Algorithm Steps

Count the degree (number of connections) for each city
Sort cities by their degree in ascending order
Assign values 1 to n to cities in order of increasing degree
Calculate total importance using assigned values

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Degrees

Count how many roads connect to each city

Sort by Degree

Arrange cities from lowest to highest degree

Assign Values

Give value 1 to lowest degree, value n to highest degree

Calculate Total

Sum importance of all roads

Code -

solution.c — C

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

struct CityDegree {
    int city;
    int degree;
};

int compare(const void* a, const void* b) {
    struct CityDegree* ca = (struct CityDegree*)a;
    struct CityDegree* cb = (struct CityDegree*)b;
    return ca->degree - cb->degree;
}

long long maximumImportance(int n, int roads[][2], int numRoads) {
    // Count degree of each city
    int* degree = calloc(n, sizeof(int));
    for (int i = 0; i < numRoads; i++) {
        degree[roads[i][0]]++;
        degree[roads[i][1]]++;
    }
    
    // Create city-degree pairs and sort
    struct CityDegree* cityDegrees = malloc(n * sizeof(struct CityDegree));
    for (int i = 0; i < n; i++) {
        cityDegrees[i].city = i;
        cityDegrees[i].degree = degree[i];
    }
    qsort(cityDegrees, n, sizeof(struct CityDegree), compare);
    
    // Assign values
    long long* values = malloc(n * sizeof(long long));
    for (int i = 0; i < n; i++) {
        values[cityDegrees[i].city] = i + 1;
    }
    
    // Calculate total importance
    long long total = 0;
    for (int i = 0; i < numRoads; i++) {
        total += values[roads[i][0]] + values[roads[i][1]];
    }
    
    free(degree);
    free(cityDegrees);
    free(values);
    return total;
}

int main() {
    int roads[][2] = {{0,1},{1,2},{2,3}};
    printf("%lld\n", maximumImportance(4, roads, 3));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m + n log n)

O(m) to count degrees, O(n log n) to sort cities by degree, O(m) to calculate final total

⚡ Linearithmic

Space Complexity

O(n)

Space for degree array and city-degree pairs

⚡ Linearithmic Space

78.6K Views

Medium Frequency

~18 min Avg. Time

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

Greedy by Degree (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler