Remove Max Number of Edges to Keep Graph Fully Traversable

Remove Max Number of Edges to Keep Graph Fully Traversable - Problem

Imagine Alice and Bob are explorers navigating a mysterious network of interconnected cities. They have a map showing n cities connected by three different types of roads:

Type 1 roads: Only Alice can travel on these (restricted access)
Type 2 roads: Only Bob can travel on these (different restrictions)
Type 3 roads: Both Alice and Bob can use these (public roads)

Your mission is to remove the maximum number of roads while ensuring both explorers can still reach every city from any starting point. Think of it as optimizing the road network - keeping only the essential connections.

Given an array edges where edges[i] = [type, u, v] represents a bidirectional road of the specified type between cities u and v, return the maximum number of roads you can remove. If it's impossible for both Alice and Bob to fully traverse the network, return -1.

Input & Output

example_1.py — Basic Connected Graph

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

› Output: 2

💡 Note: We can remove 2 edges and keep the graph fully traversable by both Alice and Bob. The optimal solution keeps edges that form minimum spanning trees for both Alice's and Bob's graphs. Type 3 edges are prioritized since they benefit both users.

example_2.py — Impossible Case

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

› Output: -1

💡 Note: Bob cannot reach node 4 because there's no Type 2 or Type 3 edge connecting to node 4 that Bob can use. Only Alice can use the Type 1 edge to reach node 4, making it impossible for Bob to fully traverse the graph.

example_3.py — Minimum Case

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

› Output: 2

💡 Note: Only one edge is needed to connect 2 nodes. The Type 3 edge can be used by both Alice and Bob, so the two Type 1 and Type 2 edges are redundant and can be removed.

Constraints

1 ≤ n ≤ 10⁵
1 ≤ edges.length ≤ min(10⁵, 3 × n × (n - 1) / 2)
edges[i].length == 3
1 ≤ type_i ≤ 3
1 ≤ u_i < v_i ≤ n
All tuples (type_i, u_i, v_i) are distinct

Visualization

Tap to expand

Understanding the Visualization

Inventory Assessment

Catalog all roads: shared highways (Type 3), car-only roads (Type 1), and truck-only roads (Type 2)

Shared Infrastructure First

Build shared highways first - they're most efficient since both vehicle types benefit

Fill Gaps

Add specialized roads (Type 1 for cars, Type 2 for trucks) only where needed for connectivity

Calculate Savings

Count essential roads, subtract from total to find how many can be closed

Key Takeaway

🎯 Key Insight: Shared resources (Type 3 edges) are most valuable in network optimization because they simultaneously contribute to multiple objectives, maximizing efficiency while minimizing redundancy.

Asked in

G Google 28 a Amazon 15 f Meta 12 ⊞ Microsoft 8

The optimal solution uses Union-Find data structure with a greedy approach. Key insight: Type 3 edges are most valuable since they contribute to both Alice's and Bob's connectivity. Process edges in priority order: Type 3 first, then Type 1 and Type 2. Count essential edges needed for connectivity, subtract from total to get removable edges.

Common Approaches

Approach	Time	Space	Notes
✓ Union-Find (Optimal)	O(m × α(n))	O(n)	Use Union-Find to greedily build minimum spanning trees, prioritizing shared edges
Brute Force (Try All Combinations)	O(2^m × (n + m))	O(n + m)	Try removing every possible subset of edges and check if both graphs remain connected

Union-Find (Optimal) — Algorithm Steps

Initialize two Union-Find structures for Alice and Bob
First pass: Add all Type 3 edges to both Union-Find structures
Count how many Type 3 edges were actually used (contributed to connectivity)
Second pass: Add Type 1 edges to Alice's Union-Find and Type 2 edges to Bob's
Count total edges used and subtract from total edges to get removable count

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create separate Union-Find structures for Alice and Bob

Process Type 3

Add shared edges first - they benefit both graphs simultaneously

Process Type 1

Add Alice-only edges to complete her connectivity

Process Type 2

Add Bob-only edges to complete his connectivity

Calculate Result

Total edges minus essential edges equals removable edges

Code -

solution.c — C

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

typedef struct {
    int* parent;
    int* rank;
    int components;
    int n;
} UnionFind;

UnionFind* createUnionFind(int n) {
    UnionFind* uf = malloc(sizeof(UnionFind));
    uf->parent = malloc((n + 1) * sizeof(int));
    uf->rank = calloc(n + 1, sizeof(int));
    uf->components = n;
    uf->n = n;
    
    for (int i = 1; i <= n; i++) {
        uf->parent[i] = i;
    }
    
    return uf;
}

int find(UnionFind* uf, int x) {
    if (uf->parent[x] != x) {
        uf->parent[x] = find(uf, uf->parent[x]);
    }
    return uf->parent[x];
}

bool unionSets(UnionFind* uf, int x, int y) {
    int px = find(uf, x);
    int py = find(uf, y);
    
    if (px == py) return false;
    
    if (uf->rank[px] < uf->rank[py]) {
        uf->parent[px] = py;
    } else if (uf->rank[px] > uf->rank[py]) {
        uf->parent[py] = px;
    } else {
        uf->parent[py] = px;
        uf->rank[px]++;
    }
    
    uf->components--;
    return true;
}

bool isConnected(UnionFind* uf) {
    return uf->components == 1;
}

int maxNumEdgesToRemove(int n, int** edges, int edgesSize, int* edgesColSize) {
    UnionFind* aliceUF = createUnionFind(n);
    UnionFind* bobUF = createUnionFind(n);
    int usedEdges = 0;
    
    // First pass: Type 3 edges
    for (int i = 0; i < edgesSize; i++) {
        if (edges[i][0] == 3) {
            bool aliceAdded = unionSets(aliceUF, edges[i][1], edges[i][2]);
            bool bobAdded = unionSets(bobUF, edges[i][1], edges[i][2]);
            if (aliceAdded || bobAdded) {
                usedEdges++;
            }
        }
    }
    
    // Second pass: Type 1 and Type 2 edges
    for (int i = 0; i < edgesSize; i++) {
        if (edges[i][0] == 1) {
            if (unionSets(aliceUF, edges[i][1], edges[i][2])) {
                usedEdges++;
            }
        } else if (edges[i][0] == 2) {
            if (unionSets(bobUF, edges[i][1], edges[i][2])) {
                usedEdges++;
            }
        }
    }
    
    if (isConnected(aliceUF) && isConnected(bobUF)) {
        free(aliceUF->parent);
        free(aliceUF->rank);
        free(aliceUF);
        free(bobUF->parent);
        free(bobUF->rank);
        free(bobUF);
        return edgesSize - usedEdges;
    } else {
        free(aliceUF->parent);
        free(aliceUF->rank);
        free(aliceUF);
        free(bobUF->parent);
        free(bobUF->rank);
        free(bobUF);
        return -1;
    }
}

int main() {
    // Parse input and solve
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × α(n))

m edges processed, each Union-Find operation takes nearly constant α(n) amortized time

✓ Linear Growth

Space Complexity

O(n)

Two Union-Find structures, each storing parent and rank arrays of size n

⚡ Linearithmic Space

23.5K Views

Medium Frequency

~25 min Avg. Time

890 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

Union-Find (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler