Number of Possible Sets of Closing Branches

Number of Possible Sets of Closing Branches - Problem

A company has n branches connected by roads across the country. Due to excessive travel time between branches, they want to close some branches to optimize operations.

The key constraint: all remaining branches must be within maxDistance of each other. When a branch closes, all roads connected to it become inaccessible.

Goal: Count how many different valid sets of branches can remain open (including keeping all branches open if possible).

Input:

n: number of branches
maxDistance: maximum allowed distance between any two remaining branches
roads: array of [u, v, weight] representing roads between branches

Output: Number of possible valid sets of remaining branches.

Input & Output

example_1.py — Simple Triangle

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

› Output: 5

💡 Note: Valid subsets: {} (empty), {0}, {1}, {2}, {0,1}. The subset {0,2} has distance 10 ≤ 12, {1,2} has distance 10 ≤ 12, and {0,1,2} has max distance 10 ≤ 12, so total is 8 valid subsets.

example_2.py — Linear Chain

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

› Output: 5

💡 Note: Valid subsets: {}, {0}, {1}, {2}, {0,1}. Subsets {0,2}, {1,2}, {0,1,2} are invalid because distance between 0 and 2 is 12 > 5.

example_3.py — Single Node

$ Input: n = 1, maxDistance = 10, roads = []

› Output: 2

💡 Note: Valid subsets: {} (empty set) and {0} (single branch). Both satisfy the constraint trivially.

Visualization

Tap to expand

Understanding the Visualization

Enumerate Possibilities

Consider all 2^n ways to close branches using bitmasks

Extract Subgraph

For each subset, build the network of remaining branches

Compute Distances

Use Floyd-Warshall to find shortest paths between all remaining branches

Validate Constraint

Check if maximum distance ≤ maxDistance requirement is satisfied

Key Takeaway

🎯 Key Insight: This is a classic enumeration problem where we must check all possible combinations. The exponential time is unavoidable, but the constraint n ≤ 15 makes it computationally feasible.

Time & Space Complexity

Time Complexity

⏱️

O(2^n × n^3)

2^n subsets, each requiring O(n^3) Floyd-Warshall computation

⚠ Quadratic Growth

Space Complexity

O(n^2)

Distance matrix for Floyd-Warshall algorithm

⚠ Quadratic Space

Constraints

1 ≤ n ≤ 15
1 ≤ maxDistance ≤ 10⁵
0 ≤ roads.length ≤ n × (n-1) / 2
roads[i].length == 3
0 ≤ u_i, v_i ≤ n-1
u_i ≠ v_i
1 ≤ w_i ≤ 10⁵
At most one road between any pair of branches

Asked in

G Google 45 a Amazon 32 f Meta 28 ⊞ Microsoft 22

The optimal approach uses bit manipulation to enumerate all 2ⁿ possible subsets of branches, then applies Floyd-Warshall algorithm to compute shortest paths within each subset. Time complexity is O(2ⁿ × n³), which is acceptable given the constraint n ≤ 15. The key insight is that we must check connectivity and distance constraints for every possible combination of remaining branches.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Bit Enumeration + Floyd-Warshall)	O(2^n × n^3)	O(n^2)	Try all 2^n possible subsets of branches and check connectivity

Brute Force (Bit Enumeration + Floyd-Warshall) — Algorithm Steps

Generate all 2^n possible subsets using bit manipulation
For each subset, extract the subgraph of remaining branches
Use Floyd-Warshall to find shortest paths between all pairs
Check if maximum distance ≤ maxDistance
Count valid subsets

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subset

Use bitmask to represent which branches to keep open

Build Subgraph

Extract edges between remaining branches only

Compute Distances

Use Floyd-Warshall to find shortest paths

Validate Constraint

Check if max distance ≤ maxDistance

Code -

solution.c — C

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

#define INF (INT_MAX / 2)
#define min(a, b) ((a) < (b) ? (a) : (b))

int indexOf(int* arr, int size, int val) {
    for (int i = 0; i < size; i++) {
        if (arr[i] == val) return i;
    }
    return -1;
}

int isValidSubset(int mask, int n, int maxDistance, int** roads, int roadsSize) {
    int active[15];
    int activeSize = 0;
    
    for (int i = 0; i < n; i++) {
        if (mask & (1 << i)) {
            active[activeSize++] = i;
        }
    }
    
    if (activeSize <= 1) return 1;
    
    int dist[15][15];
    
    // Initialize
    for (int i = 0; i < activeSize; i++) {
        for (int j = 0; j < activeSize; j++) {
            dist[i][j] = (i == j) ? 0 : INF;
        }
    }
    
    // Add edges
    for (int r = 0; r < roadsSize; r++) {
        int u = roads[r][0], v = roads[r][1], w = roads[r][2];
        if ((mask & (1 << u)) && (mask & (1 << v))) {
            int uIdx = indexOf(active, activeSize, u);
            int vIdx = indexOf(active, activeSize, v);
            if (uIdx != -1 && vIdx != -1) {
                dist[uIdx][vIdx] = min(dist[uIdx][vIdx], w);
                dist[vIdx][uIdx] = min(dist[vIdx][uIdx], w);
            }
        }
    }
    
    // Floyd-Warshall
    for (int k = 0; k < activeSize; k++) {
        for (int i = 0; i < activeSize; i++) {
            for (int j = 0; j < activeSize; j++) {
                if (dist[i][k] != INF && dist[k][j] != INF) {
                    dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
                }
            }
        }
    }
    
    // Check constraint
    for (int i = 0; i < activeSize; i++) {
        for (int j = 0; j < activeSize; j++) {
            if (dist[i][j] > maxDistance) return 0;
        }
    }
    return 1;
}

int numberOfSets(int n, int maxDistance, int** roads, int roadsSize, int* roadsColSize) {
    int count = 0;
    for (int mask = 0; mask < (1 << n); mask++) {
        if (isValidSubset(mask, n, maxDistance, roads, roadsSize)) {
            count++;
        }
    }
    return count;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n × n^3)

2^n subsets, each requiring O(n^3) Floyd-Warshall computation

⚠ Quadratic Growth

Space Complexity

O(n^2)

Distance matrix for Floyd-Warshall algorithm

⚠ Quadratic Space

Constraints

1 ≤ n ≤ 15
1 ≤ maxDistance ≤ 10⁵
0 ≤ roads.length ≤ n × (n-1) / 2
roads[i].length == 3
0 ≤ u_i, v_i ≤ n-1
u_i ≠ v_i
1 ≤ w_i ≤ 10⁵
At most one road between any pair of branches

38.5K Views

Medium Frequency

~25 min Avg. Time

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

Brute Force (Bit Enumeration + Floyd-Warshall) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler