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.

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

Visualization

Tap to expand

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

✓ Binary Search + Greedy Selection (Optimal)

⏱️ Time: O(E log E + E log W * (V + E)) Space: O(V + E)

Use binary search to find the minimum possible maximum edge weight. For each candidate maximum weight, greedily select the lightest edges that satisfy constraints and check if connectivity is maintained.

Brute Force (Try All Combinations)

⏱️ Time: O(2^E * (V + E)) Space: O(V + E)

Generate all possible subsets of edges that satisfy the threshold constraint, then check if each subset maintains connectivity to node 0 from all nodes. Keep track of the minimum maximum edge weight among valid solutions.

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 <string.h>
#include <ctype.h>

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

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

typedef struct {
    int *items;
    int size;
    int capacity;
} IntList;

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++;
}

IntList* createIntList() {
    IntList *list = malloc(sizeof(IntList));
    list->items = malloc(10 * sizeof(int));
    list->size = 0;
    list->capacity = 10;
    return list;
}

void addInt(IntList *list, int item) {
    if (list->size >= list->capacity) {
        list->capacity *= 2;
        list->items = realloc(list->items, list->capacity * sizeof(int));
    }
    list->items[list->size++] = item;
}

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

int compareInts(const void *a, const void *b) {
    return (*(int*)a) - (*(int*)b);
}

bool canConnect(int n, int threshold, int **edges, int edgesSize, int maxWeight) {
    EdgeList **nodeEdges = malloc(n * sizeof(EdgeList*));
    for (int i = 0; i < n; i++) {
        nodeEdges[i] = createEdgeList();
    }
    
    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);
        }
    }
    
    IntList **graph = malloc(n * sizeof(IntList*));
    for (int i = 0; i < n; i++) {
        graph[i] = createIntList();
    }
    
    for (int node = 0; node < n; node++) {
        qsort(nodeEdges[node]->edges, nodeEdges[node]->size, sizeof(Edge), compareEdgesByWeight);
        
        for (int i = 0; i < nodeEdges[node]->size && i < threshold; i++) {
            int dest = nodeEdges[node]->edges[i].dest;
            addInt(graph[node], dest);
        }
    }
    
    for (int start = 1; start < n; start++) {
        bool *visited = calloc(n, sizeof(bool));
        int *queue = malloc(n * sizeof(int));
        int front = 0, rear = 0;
        
        visited[start] = true;
        queue[rear++] = start;
        
        bool found = false;
        while (front < rear && !found) {
            int node = queue[front++];
            if (node == 0) {
                found = true;
                break;
            }
            
            for (int i = 0; i < graph[node]->size; i++) {
                int neighbor = graph[node]->items[i];
                if (!visited[neighbor]) {
                    visited[neighbor] = true;
                    queue[rear++] = neighbor;
                }
            }
        }
        
        free(visited);
        free(queue);
        
        if (!found) {
            for (int i = 0; i < n; i++) {
                free(nodeEdges[i]->edges);
                free(nodeEdges[i]);
                free(graph[i]->items);
                free(graph[i]);
            }
            free(nodeEdges);
            free(graph);
            return false;
        }
    }
    
    for (int i = 0; i < n; i++) {
        free(nodeEdges[i]->edges);
        free(nodeEdges[i]);
        free(graph[i]->items);
        free(graph[i]);
    }
    free(nodeEdges);
    free(graph);
    
    return true;
}

int minimizeMaxEdgeWeight(int n, int threshold, int **edges, int edgesSize) {
    if (n == 1) return 0;
    if (threshold == 0) return -1;
    if (edgesSize == 0) return -1;
    
    int *allWeights = malloc(edgesSize * sizeof(int));
    for (int i = 0; i < edgesSize; i++) {
        allWeights[i] = edges[i][2];
    }
    qsort(allWeights, edgesSize, sizeof(int), compareInts);
    
    int *weights = malloc(edgesSize * sizeof(int));
    int weightsSize = 0;
    for (int i = 0; i < edgesSize; i++) {
        if (weightsSize == 0 || allWeights[i] != weights[weightsSize - 1]) {
            weights[weightsSize++] = allWeights[i];
        }
    }
    free(allWeights);
    
    int left = 0, right = weightsSize - 1;
    int result = -1;
    
    while (left <= right) {
        int mid = (left + right) / 2;
        if (canConnect(n, threshold, edges, edgesSize, weights[mid])) {
            result = weights[mid];
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    }
    
    free(weights);
    return result;
}

int main() {
    int n, threshold;
    scanf("%d", &n);
    scanf("%d", &threshold);
    
    char line[100000];
    scanf(" %[^\n]", line);
    
    int **edges = NULL;
    int edgesSize = 0;
    
    if (strcmp(line, "[]") != 0) {
        char *ptr = line;
        
        // Skip initial '['
        while (*ptr && *ptr != '[') ptr++;
        if (*ptr == '[') ptr++;
        
        while (*ptr) {
            // Skip whitespace and commas
            while (*ptr && (*ptr == ' ' || *ptr == ',' || *ptr == '\t')) ptr++;
            
            if (*ptr == '[') {
                ptr++; // Skip '['
                
                // Parse three integers
                int nums[3];
                for (int i = 0; i < 3; i++) {
                    // Skip whitespace
                    while (*ptr && (*ptr == ' ' || *ptr == '\t')) ptr++;
                    
                    // Parse number
                    char *end;
                    nums[i] = strtol(ptr, &end, 10);
                    ptr = end;
                    
                    // Skip comma if not last number
                    if (i < 2) {
                        while (*ptr && (*ptr == ' ' || *ptr == '\t')) ptr++;
                        if (*ptr == ',') ptr++;
                    }
                }
                
                // Skip to closing ']'
                while (*ptr && *ptr != ']') ptr++;
                if (*ptr == ']') ptr++;
                
                // Add edge
                edges = realloc(edges, (edgesSize + 1) * sizeof(int*));
                edges[edgesSize] = malloc(3 * sizeof(int));
                edges[edgesSize][0] = nums[0];
                edges[edgesSize][1] = nums[1];
                edges[edgesSize][2] = nums[2];
                edgesSize++;
                
            } else if (*ptr == ']') {
                break;
            } else {
                ptr++;
            }
        }
    }
    
    printf("%d\n", minimizeMaxEdgeWeight(n, threshold, edges, edgesSize));
    
    for (int i = 0; i < edgesSize; i++) {
        free(edges[i]);
    }
    free(edges);
    
    return 0;
}

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

✓ Linear Growth

Space Complexity

O(V + E)

Space for graph representation and connectivity verification

✓ Linear Space

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

Constraints

Visualization

Related Problems

Common Approaches

Binary Search + Greedy Selection (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler