Minimize the Maximum Edge Weight of Graph

Minimize the Maximum Edge Weight of Graph - Problem

Imagine you're designing a transportation network where all cities must be able to reach the capital (node 0), but you want to minimize the heaviest route needed. You're given a directed weighted graph with n nodes (0 to n-1) and a list of edges with weights.

Your challenge is to remove some edges from the graph such that:

Connectivity: Node 0 must be reachable from every other node
Efficiency: The maximum edge weight in the final graph is minimized
Constraint: Each node can have at most threshold outgoing edges

Return the minimum possible maximum edge weight after optimal edge removal, or -1 if impossible.

Example: With nodes [0,1,2], edges [[1,0,1], [2,0,2], [1,0,3]], and threshold=1, we can keep edges with weights 1 and 2, giving us a maximum weight of 2.

Input & Output

example_1.py — Basic Case

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

› Output: 2

💡 Note: We need all nodes to reach node 0. Keep edges [1,0,1] and [2,0,2] (weights 1,2). Node 1 reaches 0 directly, node 2 reaches 0 directly. Maximum edge weight is 2.

example_2.py — Threshold Constraint

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

› Output: 3

💡 Note: With threshold=1, each node can have at most 1 outgoing edge. We can use [3,0,1], [1,3,2], [2,0,3]. All nodes reach 0: 1→3→0, 2→0, 3→0. Maximum weight is 3.

example_3.py — Impossible Case

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

› Output: -1

💡 Note: Node 0 has outgoing edges but we need nodes 1 and 2 to reach node 0. With only outgoing edges from node 0, nodes 1 and 2 cannot reach node 0.

Visualization

Tap to expand

Understanding the Visualization

Identify Goal

All nodes must be able to reach node 0 (the emergency shelter)

Apply Constraints

Each node can maintain at most 'threshold' outgoing roads due to budget limits

Binary Search

Search for the minimum possible 'maximum difficulty level' needed

Greedy Selection

For each candidate difficulty, greedily choose the easiest roads

Verify Connectivity

Check if all neighborhoods can still reach the shelter

Key Takeaway

🎯 Key Insight: Binary search on the maximum edge weight combined with greedy selection of lightest edges ensures optimal connectivity while respecting threshold constraints.

Time & Space Complexity

Time Complexity

⏱️

O(E log E + E log W * (V + E))

E log E for sorting, log W binary search iterations, each taking O(V + E) for connectivity check

⚡ Linearithmic

Space Complexity

O(V + E)

Space for graph representation and connectivity verification

✓ Linear Space

Constraints

1 ≤ n ≤ 10⁵
0 ≤ threshold ≤ n - 1
0 ≤ edges.length ≤ min(10⁵, n * (n - 1))
edges[i] = [A_i, B_i, W_i]
0 ≤ A_i, B_i ≤ n - 1
A_i ≠ B_i
1 ≤ W_i ≤ 10⁶
No duplicate edges between same pair of nodes

Asked in

G Google 28 a Amazon 22 ⊞ Microsoft 18 f Meta 15

The optimal approach uses binary search on the answer combined with greedy edge selection. We search for the minimum possible maximum edge weight, and for each candidate weight, greedily select the lightest edges while respecting the threshold constraint. The key insight is that if we can achieve connectivity with maximum weight X, we can also achieve it with any weight > X, making binary search applicable.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search + Greedy Selection (Optimal)	O(E log E + E log W * (V + E))	O(V + E)	Binary search on maximum edge weight with greedy edge selection
Brute Force (Try All Combinations)	O(2^E * (V + E))	O(V + E)	Try all possible edge combinations and check connectivity

Binary Search + Greedy Selection (Optimal) — Algorithm Steps

Sort edges by weight for efficient processing
Binary search on the maximum edge weight (from min to max edge weight)
For each candidate weight, greedily select edges not exceeding that weight
Check if selected edges maintain connectivity while respecting threshold constraints
Adjust search range based on feasibility

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Edges

Sort all edges by weight for efficient processing

Binary Search

Search for minimum possible maximum edge weight

Greedy Selection

For each candidate weight, greedily select lightest edges

Connectivity Check

Verify all nodes can reach node 0

Code -

solution.c — C

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

typedef struct {
    int dest;
    int weight;
} Edge;

typedef struct {
    Edge *edges;
    int size;
    int capacity;
} EdgeList;

int compareEdges(const void *a, const void *b) {
    int *edgeA = *(int**)a;
    int *edgeB = *(int**)b;
    return edgeA[2] - edgeB[2];
}

int compareEdgesByWeight(const void *a, const void *b) {
    Edge *edgeA = (Edge*)a;
    Edge *edgeB = (Edge*)b;
    return edgeA->weight - edgeB->weight;
}

EdgeList* createEdgeList() {
    EdgeList *list = malloc(sizeof(EdgeList));
    list->edges = malloc(10 * sizeof(Edge));
    list->size = 0;
    list->capacity = 10;
    return list;
}

void addEdge(EdgeList *list, int dest, int weight) {
    if (list->size >= list->capacity) {
        list->capacity *= 2;
        list->edges = realloc(list->edges, list->capacity * sizeof(Edge));
    }
    list->edges[list->size].dest = dest;
    list->edges[list->size].weight = weight;
    list->size++;
}

bool canConnect(int n, int threshold, int **edges, int edgesSize, int maxWeight) {
    EdgeList **nodeEdges = malloc(n * sizeof(EdgeList*));
    int **graph = malloc(n * sizeof(int*));
    int *graphSizes = calloc(n, sizeof(int));
    
    // Initialize
    for (int i = 0; i < n; i++) {
        nodeEdges[i] = createEdgeList();
        graph[i] = malloc(n * sizeof(int));
    }
    
    // Collect edges with weight <= maxWeight
    for (int i = 0; i < edgesSize; i++) {
        int a = edges[i][0], b = edges[i][1], w = edges[i][2];
        if (w <= maxWeight) {
            addEdge(nodeEdges[a], b, w);
        }
    }
    
    // For each node, select up to threshold lightest outgoing edges
    for (int node = 0; node < n; node++) {
        qsort(nodeEdges[node]->edges, nodeEdges[node]->size, sizeof(Edge), compareEdgesByWeight);
        
        int limit = threshold < nodeEdges[node]->size ? threshold : nodeEdges[node]->size;
        for (int i = 0; i < limit; i++) {
            int dest = nodeEdges[node]->edges[i].dest;
            graph[dest][graphSizes[dest]++] = node; // Reverse edge
        }
    }
    
    // BFS from node 0
    bool *visited = calloc(n, sizeof(bool));
    int *queue = malloc(n * sizeof(int));
    int front = 0, rear = 0;
    
    visited[0] = true;
    queue[rear++] = 0;
    
    while (front < rear) {
        int node = queue[front++];
        for (int i = 0; i < graphSizes[node]; i++) {
            int neighbor = graph[node][i];
            if (!visited[neighbor]) {
                visited[neighbor] = true;
                queue[rear++] = neighbor;
            }
        }
    }
    
    int visitedCount = 0;
    for (int i = 0; i < n; i++) {
        if (visited[i]) visitedCount++;
    }
    
    return visitedCount == n;
}

int minimizeMaxEdgeWeight(int n, int threshold, int **edges, int edgesSize) {
    if (edgesSize == 0) {
        return n == 1 ? 0 : -1;
    }
    
    // Sort edges by weight
    qsort(edges, edgesSize, sizeof(int*), compareEdges);
    
    int left = edges[0][2];
    int right = edges[edgesSize-1][2];
    int result = -1;
    
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (canConnect(n, threshold, edges, edgesSize, mid)) {
            result = mid;
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(E log E + E log W * (V + E))

E log E for sorting, log W binary search iterations, each taking O(V + E) for connectivity check

⚡ Linearithmic

Space Complexity

O(V + E)

Space for graph representation and connectivity verification

✓ Linear Space

Constraints

1 ≤ n ≤ 10⁵
0 ≤ threshold ≤ n - 1
0 ≤ edges.length ≤ min(10⁵, n * (n - 1))
edges[i] = [A_i, B_i, W_i]
0 ≤ A_i, B_i ≤ n - 1
A_i ≠ B_i
1 ≤ W_i ≤ 10⁶
No duplicate edges between same pair of nodes

23.5K Views

Medium Frequency

~25 min Avg. Time

847 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

Binary Search + Greedy Selection (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler