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

Alice and Bob have an undirected graph of n nodes and three types of edges:

Type 1: Can be traversed by Alice only.
Type 2: Can be traversed by Bob only.
Type 3: Can be traversed by both Alice and Bob.

Given an array edges where edges[i] = [type_i, u_i, v_i] represents a bidirectional edge of type type_i between nodes u_i and v_i, find the maximum number of edges you can remove so that after removing the edges, the graph can still be fully traversed by both Alice and Bob.

The graph is fully traversed by Alice and Bob if starting from any node, they can reach all other nodes.

Return the maximum number of edges you can remove, or return -1 if Alice and Bob cannot fully traverse the graph.

Input & Output

Example 1 — Basic 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: Alice needs edges connecting all nodes using type 1 and 3. Bob needs edges using type 2 and 3. The minimum spanning trees need 4 edges total (3 for connectivity + 1 extra for different requirements), so we can remove 6 - 4 = 2 edges.

Example 2 — Impossible Case

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

› Output: -1

💡 Note: Alice cannot reach node 4 from nodes 1,2,3 using type 1 and 3 edges. Bob cannot reach node 1 from other nodes using type 2 and 3 edges. Full traversal is impossible.

Example 3 — All Shared Edges

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

› Output: 1

💡 Note: All edges are type 3 (shared). We need only 2 edges to connect 3 nodes (minimum spanning tree), so we can remove 3 - 2 = 1 edge.

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

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to use Union-Find with greedy edge selection. Process type 3 (shared) edges first since they help both Alice and Bob simultaneously. Then add type 1 and type 2 edges only when needed to maintain connectivity. Best approach uses Union-Find: Time O(m×α(n)), Space O(n).

Common Approaches

✓ Brute Force - Try All Combinations

⏱️ Time: O(2^m × (m + n)) Space: O(n + m)

Generate all possible subsets of edges and check if each subset allows both Alice and Bob to fully traverse the graph. Count valid subsets and find the one with minimum edges.

Union-Find with Greedy Edge Selection

⏱️ Time: O(m × α(n)) Space: O(n)

Build minimum spanning trees for Alice and Bob using Union-Find. Process type 3 edges first since they help both players. Then add type 1 and type 2 edges as needed to complete connectivity.

Brute Force - Try All Combinations — Algorithm Steps

Generate all 2^m possible edge subsets
For each subset, check if Alice can traverse all nodes
Check if Bob can traverse all nodes
Track minimum edges needed for valid traversal

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subsets

Create all 2^m possible combinations of edges

Check Connectivity

For each subset, verify Alice and Bob can traverse all nodes

Find Minimum

Track smallest valid edge set, return total - minimum

Code -

solution.c — C

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

static int edges[1000][3];
static int graph[101][1000];
static int graphSize[101];
static bool visited[101];
static int stack[1000];
static int stackSize;
static int selectedEdges[1000][3];
static int aliceEdges[1000][3];
static int bobEdges[1000][3];
static int combination[1000];

void push(int val) {
    stack[stackSize++] = val;
}

int pop() {
    return stack[--stackSize];
}

bool isEmpty() {
    return stackSize == 0;
}

bool canTraverse(int personEdges[][3], int edgeCount, int n) {
    if (edgeCount == 0) {
        return n <= 1;
    }
    
    // Build adjacency list
    for (int i = 0; i <= n; i++) {
        graphSize[i] = 0;
    }
    
    for (int i = 0; i < edgeCount; i++) {
        int u = personEdges[i][1];
        int v = personEdges[i][2];
        graph[u][graphSize[u]++] = v;
        graph[v][graphSize[v]++] = u;
    }
    
    // DFS from node 1
    for (int i = 0; i <= n; i++) {
        visited[i] = false;
    }
    
    stackSize = 0;
    push(1);
    visited[1] = true;
    int count = 1;
    
    while (!isEmpty()) {
        int node = pop();
        for (int i = 0; i < graphSize[node]; i++) {
            int neighbor = graph[node][i];
            if (!visited[neighbor]) {
                visited[neighbor] = true;
                push(neighbor);
                count++;
            }
        }
    }
    
    return count == n;
}

void generateCombinations(int m, int r, int start, int currentSize, int* result) {
    if (currentSize == r) {
        (*result)++;
        
        // Build selected edges
        int selectedCount = 0;
        for (int i = 0; i < r; i++) {
            selectedEdges[selectedCount][0] = edges[combination[i]][0];
            selectedEdges[selectedCount][1] = edges[combination[i]][1];
            selectedEdges[selectedCount][2] = edges[combination[i]][2];
            selectedCount++;
        }
        
        return;
    }
    
    for (int i = start; i <= m - (r - currentSize); i++) {
        combination[currentSize] = i;
        generateCombinations(m, r, i + 1, currentSize + 1, result);
    }
}

int solution(int n, int m) {
    int minEdges = INT_MAX;
    
    // Try all possible subsets (r from 0 to m)
    for (int r = 0; r <= m; r++) {
        // Generate all combinations of size r
        int combCount = 0;
        
        // Manual implementation of combinations
        if (r == 0) {
            // Empty subset
            int aliceCount = 0;
            int bobCount = 0;
            
            if (!canTraverse(aliceEdges, aliceCount, n)) {
                continue;
            }
            if (!canTraverse(bobEdges, bobCount, n)) {
                continue;
            }
            
            if (0 < minEdges) {
                minEdges = 0;
            }
        } else {
            // Use bit manipulation for combinations up to reasonable size
            int maxMask = (m <= 20) ? (1 << m) : (1 << 20);
            int actualM = (m <= 20) ? m : 20;
            
            for (int mask = 0; mask < maxMask; mask++) {
                int bits = 0;
                for (int i = 0; i < actualM; i++) {
                    if (mask & (1 << i)) bits++;
                }
                if (bits != r) continue;
                
                int selectedCount = 0;
                for (int i = 0; i < actualM; i++) {
                    if (mask & (1 << i)) {
                        selectedEdges[selectedCount][0] = edges[i][0];
                        selectedEdges[selectedCount][1] = edges[i][1];
                        selectedEdges[selectedCount][2] = edges[i][2];
                        selectedCount++;
                    }
                }
                
                // Check Alice (type 1 and 3)
                int aliceCount = 0;
                for (int i = 0; i < selectedCount; i++) {
                    if (selectedEdges[i][0] == 1 || selectedEdges[i][0] == 3) {
                        aliceEdges[aliceCount][0] = selectedEdges[i][0];
                        aliceEdges[aliceCount][1] = selectedEdges[i][1];
                        aliceEdges[aliceCount][2] = selectedEdges[i][2];
                        aliceCount++;
                    }
                }
                if (!canTraverse(aliceEdges, aliceCount, n)) {
                    continue;
                }
                
                // Check Bob (type 2 and 3)
                int bobCount = 0;
                for (int i = 0; i < selectedCount; i++) {
                    if (selectedEdges[i][0] == 2 || selectedEdges[i][0] == 3) {
                        bobEdges[bobCount][0] = selectedEdges[i][0];
                        bobEdges[bobCount][1] = selectedEdges[i][1];
                        bobEdges[bobCount][2] = selectedEdges[i][2];
                        bobCount++;
                    }
                }
                if (!canTraverse(bobEdges, bobCount, n)) {
                    continue;
                }
                
                if (selectedCount < minEdges) {
                    minEdges = selectedCount;
                }
            }
        }
    }
    
    return minEdges == INT_MAX ? -1 : m - minEdges;
}

int main() {
    int n;
    scanf("%d", &n);
    
    char line[10000];
    fgets(line, sizeof(line), stdin);
    fgets(line, sizeof(line), stdin);
    
    int m = 0;
    int pos = 0;
    int len = strlen(line);
    
    while (pos < len) {
        if (line[pos] == '[' && pos + 1 < len && (line[pos + 1] >= '0' && line[pos + 1] <= '9')) {
            pos++; // skip '['
            for (int i = 0; i < 3; i++) {
                int num = 0;
                while (pos < len && line[pos] >= '0' && line[pos] <= '9') {
                    num = num * 10 + (line[pos] - '0');
                    pos++;
                }
                edges[m][i] = num;
                if (i < 2 && pos < len && line[pos] == ',') {
                    pos++; // skip ','
                }
            }
            m++;
            // skip to next '[' or end
            while (pos < len && line[pos] != '[') {
                pos++;
            }
        } else {
            pos++;
        }
    }
    
    int result = solution(n, m);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^m × (m + n))

2^m subsets, each requiring O(m+n) time for connectivity check using DFS

✓ Linear Growth

Space Complexity

O(n + m)

Space for recursion stack in DFS and temporary edge storage

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~35 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

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler