Count Subtrees With Max Distance Between Cities

Count Subtrees With Max Distance Between Cities - Problem

Imagine you have n cities connected by roads forming a tree structure, where every city can reach every other city through a unique path. Your task is to analyze all possible connected subsets of cities and count how many have specific maximum distances.

You're given an array edges where edges[i] = [ui, vi] represents a bidirectional road between cities ui and vi. Since the cities form a tree, there are exactly n-1 edges.

A subtree is a subset of cities where:

Every city in the subset can reach every other city in the subset
The path between any two cities passes only through cities in the subset

Goal: For each distance d from 1 to n-1, count how many subtrees have a maximum distance of exactly d between any two cities in that subtree.

Return an array where the d-th element (1-indexed) represents the count of subtrees with maximum distance d.

Input & Output

example_1.py — Basic Tree

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

› Output: [3, 2, 1]

💡 Note: Distance 1: {1,2}, {2,3}, {2,4} (3 subtrees). Distance 2: {1,2,3}, {1,2,4} (2 subtrees). Distance 3: {1,2,3,4} (1 subtree).

example_2.py — Linear Tree

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

› Output: [1]

💡 Note: Only one possible subtree with 2 cities: {1,2} with maximum distance 1.

example_3.py — Larger Tree

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

› Output: [2, 1]

💡 Note: Distance 1: {1,2}, {2,3} (2 subtrees). Distance 2: {1,2,3} (1 subtree).

Visualization

Tap to expand

Understanding the Visualization

Tree Structure

Cities are connected as islands with bridges forming a tree - no cycles, unique paths

Subset Generation

Use binary masks to represent all possible island groups (2^n possibilities)

Validation

Check if island group is connected and count bridges within the group

Distance Calculation

Find the longest bridge path within each valid island group

Counting

Group results by maximum distance and return counts

Key Takeaway

🎯 Key Insight: By representing subsets as bitmasks and using tree diameter properties, we can efficiently check all 2^n possible island groups and calculate their maximum distances in O(n·2^n) time instead of the naive O(n·4^n).

Time & Space Complexity

Time Complexity

⏱️

O(n * 2^n)

2^n subsets, each requiring O(n) operations for validation and diameter calculation

⚠ Quadratic Growth

Space Complexity

O(n)

Adjacency list storage and BFS temporary arrays

⚡ Linearithmic Space

Constraints

2 ≤ n ≤ 15
edges.length == n - 1
edges[i].length == 2
1 ≤ u_i, v_i ≤ n
The given input represents a valid tree

Asked in

G Google 25 ⊞ Microsoft 18 a Amazon 12 f Meta 8

The optimal approach uses bitmask enumeration to represent all possible subsets of cities, then leverages tree properties for efficient validation. Key insights: (1) Check connectivity by counting edges - valid subtrees need exactly |cities|-1 edges, (2) Use tree diameter algorithm with two BFS calls instead of checking all pairs, achieving O(n·2^n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Enumeration	O(n * 4^n)	O(n^2)	Check all possible subsets, validate connectivity, and compute maximum distances
Optimized Bitmask with Tree Properties	O(n * 2^n)	O(n)	Use bitmask enumeration with efficient connectivity and distance validation

Brute Force Enumeration — Algorithm Steps

Generate all 2^n possible subsets of cities
For each subset, check if it forms a connected component
If connected, compute distances between all pairs in the subset
Find the maximum distance and increment the corresponding counter
Return the result array

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subsets

Use bitmasks to generate all 2^n possible subsets of cities

Check Connectivity

For each subset, run BFS/DFS to verify all cities are connected

Calculate Distances

If connected, compute distances between all pairs using BFS

Find Maximum

Determine the maximum distance in the subset and count it

Code -

solution.c — C

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

#define MAX_N 15

int graph[MAX_N + 1][MAX_N + 1];
int graphSize[MAX_N + 1];

int isConnected(int* cities, int cityCount, int n) {
    if (cityCount <= 1) return 1;
    
    int visited[MAX_N + 1] = {0};
    int queue[MAX_N + 1];
    int front = 0, rear = 0;
    
    queue[rear++] = cities[0];
    visited[cities[0]] = 1;
    int visitedCount = 1;
    
    while (front < rear) {
        int node = queue[front++];
        
        for (int i = 0; i < graphSize[node]; i++) {
            int neighbor = graph[node][i];
            int inCities = 0;
            
            for (int j = 0; j < cityCount; j++) {
                if (cities[j] == neighbor) {
                    inCities = 1;
                    break;
                }
            }
            
            if (inCities && !visited[neighbor]) {
                visited[neighbor] = 1;
                visitedCount++;
                queue[rear++] = neighbor;
            }
        }
    }
    
    return visitedCount == cityCount;
}

int maxDistance(int* cities, int cityCount, int n) {
    if (cityCount <= 1) return 0;
    
    int maxDist = 0;
    
    for (int s = 0; s < cityCount; s++) {
        int start = cities[s];
        int distances[MAX_N + 1];
        for (int i = 0; i <= n; i++) distances[i] = -1;
        
        int queue[MAX_N + 1];
        int front = 0, rear = 0;
        
        queue[rear++] = start;
        distances[start] = 0;
        
        while (front < rear) {
            int node = queue[front++];
            
            for (int i = 0; i < graphSize[node]; i++) {
                int neighbor = graph[node][i];
                int inCities = 0;
                
                for (int j = 0; j < cityCount; j++) {
                    if (cities[j] == neighbor) {
                        inCities = 1;
                        break;
                    }
                }
                
                if (inCities && distances[neighbor] == -1) {
                    distances[neighbor] = distances[node] + 1;
                    if (distances[neighbor] > maxDist) {
                        maxDist = distances[neighbor];
                    }
                    queue[rear++] = neighbor;
                }
            }
        }
    }
    
    return maxDist;
}

int* countSubtreesWithMaxDistance(int n, int** edges, int edgesSize, int* edgesColSize, int* returnSize) {
    *returnSize = n - 1;
    int* result = (int*)calloc(n - 1, sizeof(int));
    
    // Initialize graph
    memset(graphSize, 0, sizeof(graphSize));
    
    for (int i = 0; i < edgesSize; i++) {
        int u = edges[i][0], v = edges[i][1];
        graph[u][graphSize[u]++] = v;
        graph[v][graphSize[v]++] = u;
    }
    
    for (int mask = 1; mask < (1 << n); mask++) {
        int cities[MAX_N];
        int cityCount = 0;
        
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                cities[cityCount++] = i + 1;
            }
        }
        
        if (cityCount >= 2 && isConnected(cities, cityCount, n)) {
            int dist = maxDistance(cities, cityCount, n);
            if (dist > 0) {
                result[dist - 1]++;
            }
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * 4^n)

2^n subsets, each requiring O(n^2) connectivity check and distance computation

✓ Linear Growth

Space Complexity

O(n^2)

Adjacency list representation and BFS/DFS space

⚠ Quadratic Space

Constraints

2 ≤ n ≤ 15
edges.length == n - 1
edges[i].length == 2
1 ≤ u_i, v_i ≤ n
The given input represents a valid tree

23.6K Views

Medium Frequency

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

Brute Force Enumeration — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler