Count Pairs of Connectable Servers in a Weighted Tree Network

Count Pairs of Connectable Servers in a Weighted Tree Network - Problem

Imagine you're designing a network communication system for a company with n servers arranged in a tree structure. Each connection between servers has a specific weight representing the communication cost.

Your task is to determine how many pairs of servers can communicate through each intermediate server, given a specific signal speed constraint.

Communication Rules:

Two servers a and b can communicate through server c if:
a < b (to avoid counting pairs twice)
Both a and b are different from c
The distance from c to a is divisible by signalSpeed
The distance from c to b is divisible by signalSpeed
The paths from c to a and from c to b don't share any edges

Goal: Return an array where count[i] represents the number of server pairs that can communicate through server i.

Input & Output

example_1.py — Basic Tree Network

$ Input: edges = [[0,1,1],[1,2,5],[2,3,13],[1,4,9],[4,5,2]], signalSpeed = 1

› Output: [0,4,0,0,0,0]

💡 Note: Server 1 can relay 4 pairs: (0,2), (0,3), (0,4), (0,5) since all distances are divisible by 1. Other servers have no valid pairs due to tree structure constraints.

example_2.py — Signal Speed Constraint

$ Input: edges = [[0,6,3],[6,4,2],[6,3,3],[4,5,2],[5,1,3],[3,2,3]], signalSpeed = 3

› Output: [2,0,0,1,0,0,0]

💡 Note: With signalSpeed=3, only distances divisible by 3 are valid. Server 0 can relay 2 pairs, server 3 can relay 1 pair.

example_3.py — Linear Tree

$ Input: edges = [[0,1,2],[1,2,4]], signalSpeed = 2

› Output: [0,1,0]

💡 Note: In a linear tree with 3 nodes, only the middle server (1) can act as relay. Distance 0→1=2, distance 1→2=4, both divisible by 2, so 1 pair (0,2).

Visualization

Tap to expand

Understanding the Visualization

Tree Structure

Servers are connected in a tree - no cycles, exactly n-1 edges

Signal Propagation

Signals travel along edges with cumulative weights as distances

Relay Requirements

Distance from relay to both endpoints must be divisible by signalSpeed

Path Independence

Paths to different subtrees from relay never share edges in a tree

Key Takeaway

🎯 Key Insight: In trees, we can count valid pairs efficiently by grouping nodes into subtrees and leveraging the fact that inter-subtree paths never share edges.

Time & Space Complexity

Time Complexity

⏱️

O(n³)

For each of n servers, we run DFS (O(n)) then check all pairs (O(n²))

⚠ Quadratic Growth

Space Complexity

O(n)

Space for adjacency list and recursion stack during DFS

⚡ Linearithmic Space

Constraints

2 ≤ n ≤ 1000
edges.length == n - 1
edges[i].length == 3
0 ≤ a_i, b_i < n
a_i ≠ b_i
1 ≤ weight_i, signalSpeed ≤ 10⁶
The edges form a valid tree

Asked in

f Meta 35 G Google 28 a Amazon 22 ⊞ Microsoft 18

The optimal solution uses DFS with subtree counting to achieve O(n²) time complexity. For each potential relay server, we count valid nodes in each subtree and multiply counts between different subtrees to get the total pairs. This leverages the key insight that in a tree, paths between different subtrees through a common root never share edges.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Pairs)	O(n³)	O(n)	For each server, check every possible pair of other servers
DFS with Subtree Counting (Optimal)	O(n²)	O(n)	For each server, count valid nodes in each subtree and calculate pairs

Brute Force (Check All Pairs) — Algorithm Steps

For each server c (potential relay point)
Use DFS to calculate distances from c to all other servers
For every pair (a,b) where a < b and a,b ≠ c
Check if distance(c,a) and distance(c,b) are both divisible by signalSpeed
Verify paths from c to a and c to b don't share edges (guaranteed in tree)
Count valid pairs for current relay server

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Relay Server

Choose server c as potential relay point

Calculate Distances

Use DFS to find distances from c to all other servers

Check All Pairs

For every pair (a,b) where a < b, verify distance divisibility

Count Valid Pairs

Increment counter for pairs that satisfy signal speed constraint

Code -

solution.c — C

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

typedef struct Edge {
    int to, weight;
    struct Edge* next;
} Edge;

typedef struct {
    Edge* head;
} Graph;

void addEdge(Graph* graph, int from, int to, int weight) {
    Edge* edge = (Edge*)malloc(sizeof(Edge));
    edge->to = to;
    edge->weight = weight;
    edge->next = graph[from].head;
    graph[from].head = edge;
}

int dfs(Graph* graph, int node, int parent, int target, int dist) {
    if (node == target) return dist;
    
    for (Edge* edge = graph[node].head; edge; edge = edge->next) {
        if (edge->to != parent) {
            int result = dfs(graph, edge->to, node, target, dist + edge->weight);
            if (result != -1) return result;
        }
    }
    return -1;
}

int getDistance(Graph* graph, int start, int end) {
    if (start == end) return 0;
    return dfs(graph, start, -1, end, 0);
}

int* countPairsOfConnectableServers(int** edges, int edgesSize, int* edgesColSize, int signalSpeed, int* returnSize) {
    int n = edgesSize + 1;
    *returnSize = n;
    
    Graph* graph = (Graph*)calloc(n, sizeof(Graph));
    
    // Build adjacency list
    for (int i = 0; i < edgesSize; i++) {
        int a = edges[i][0], b = edges[i][1], w = edges[i][2];
        addEdge(graph, a, b, w);
        addEdge(graph, b, a, w);
    }
    
    int* result = (int*)calloc(n, sizeof(int));
    
    // For each potential relay server
    for (int c = 0; c < n; c++) {
        int count = 0;
        // Check all pairs (a, b) where a < b
        for (int a = 0; a < n; a++) {
            for (int b = a + 1; b < n; b++) {
                if (a != c && b != c) {
                    int distCA = getDistance(graph, c, a);
                    int distCB = getDistance(graph, c, b);
                    if (distCA % signalSpeed == 0 && distCB % signalSpeed == 0) {
                        count++;
                    }
                }
            }
        }
        result[c] = count;
    }
    
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n³)

For each of n servers, we run DFS (O(n)) then check all pairs (O(n²))

⚠ Quadratic Growth

Space Complexity

O(n)

Space for adjacency list and recursion stack during DFS

⚡ Linearithmic Space

Constraints

2 ≤ n ≤ 1000
edges.length == n - 1
edges[i].length == 3
0 ≤ a_i, b_i < n
a_i ≠ b_i
1 ≤ weight_i, signalSpeed ≤ 10⁶
The edges form a valid tree

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Check All Pairs) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler