Maximum Number of K-Divisible Components - Practice Coding Problems

Maximum Number of K-Divisible Components - Problem

Maximum Number of K-Divisible Components

You are given an undirected tree with n nodes labeled from 0 to n - 1. Each node has an associated value, and your goal is to find the maximum number of components you can create by strategically removing edges.

The Challenge: You can remove any set of edges (possibly none) from the tree to create multiple connected components. However, there's a catch - each resulting component must have a sum of node values that is divisible by k.

Input:
• n - number of nodes in the tree
• edges - array of edges connecting nodes
• values - array where values[i] is the value of node i
• k - the divisor that each component's sum must satisfy

Output: Return the maximum number of valid components possible.

Example: If you have a tree where splitting creates components with sums [6, 12, 9] and k=3, all components are valid since 6%3=0, 12%3=0, and 9%3=0.

Input & Output

example_1.py — Basic Tree Split

$ Input: n = 5, edges = [[0,2],[1,2],[1,3],[1,4]], values = [1,8,1,4,4], k = 6

› Output: 2

💡 Note: We can remove the edge between nodes 1 and 2. This creates two components: {0,2} with sum 1+1=2 (not divisible by 6) and {1,3,4} with sum 8+4+4=16 (not divisible by 6). However, if we remove edges (1,3) and (1,4), we get components {0,1,2} with sum 10, {3} with sum 4, {4} with sum 4. The optimal split gives us 2 valid components.

example_2.py — All Nodes Separable

$ Input: n = 7, edges = [[0,1],[0,2],[1,3],[1,4],[2,5],[2,6]], values = [3,0,6,1,5,2,1], k = 3

› Output: 3

💡 Note: Starting from root 0, we can identify subtrees with sums divisible by 3. Node 1's subtree has sum 0+1+5=6 (divisible by 3), node 2's subtree has sum 6+2+1=9 (divisible by 3), leaving node 0 with value 3 (divisible by 3). This gives us 3 components total.

example_3.py — Single Node

$ Input: n = 1, edges = [], values = [6], k = 3

› Output: 1

💡 Note: With only one node having value 6, and 6 % 3 = 0, we can form exactly 1 valid component containing just this node.

Constraints

1 ≤ n ≤ 3 × 10⁴
edges.length == n - 1
edges[i].length == 2
0 ≤ a_i, b_i ≤ n - 1
values.length == n
-10⁹ ≤ values[i] ≤ 10⁹
1 ≤ k ≤ 10⁹
The input represents a valid tree

Visualization

Tap to expand

Understanding the Visualization

Identify the Tree Structure

Map out the company hierarchy and each person's salary (node values)

Calculate Department Budgets

Use DFS to calculate the total budget for each potential department (subtree)

Separate Valid Departments

When a department's budget is divisible by k, separate it immediately

Continue Up the Hierarchy

Return 0 to parent if separated, otherwise return the department's budget

Count Total Departments

The number of separated departments is our maximum component count

Key Takeaway

🎯 Key Insight: The greedy strategy of immediately separating valid subtrees is optimal because it never reduces the total number of components we can create. Each separated subtree becomes an independent component, and the remaining tree structure is simplified for further processing.

Asked in

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

The optimal solution uses DFS with greedy component separation. As we traverse the tree and calculate subtree sums, whenever we find a subtree whose sum is divisible by k, we immediately separate it as an independent component. This greedy approach works because separating a valid subtree early never reduces the total number of components we can create later. The algorithm runs in O(n) time with a single tree traversal.

Common Approaches

Approach	Time	Space	Notes
✓ DFS with Subtree Sum (Optimal)	O(n)	O(n)	Use DFS to calculate subtree sums and greedily separate divisible components
Brute Force (Try All Edge Combinations)	O(2^n * n)	O(n)	Try all possible combinations of edge removals and check validity

DFS with Subtree Sum (Optimal) — Algorithm Steps

Build adjacency list representation of the tree
Start DFS from any node (typically node 0)
For each node, recursively calculate the sum of its subtree
If a subtree sum is divisible by k, increment component count and reset sum to 0
Return the sum modulo k to parent (0 if component was separated)
The final answer is the total number of components found

Visualization

Tap to expand

Step-by-Step Walkthrough

Start DFS

Begin DFS traversal from root node

Calculate Subtree Sum

Recursively calculate sum of each subtree

Check Divisibility

If subtree sum % k == 0, separate it as a component

Return to Parent

Return 0 if separated, otherwise return the sum

Count Components

Total separated components is our answer

Code -

solution.c — C

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

#define MAX_N 30000

int graph[MAX_N][MAX_N];
int graphSize[MAX_N];
int components;

long long dfs(int node, int parent, int* values, int k, int n) {
    // Calculate sum of current subtree
    long long subtreeSum = values[node];
    
    for (int i = 0; i < graphSize[node]; i++) {
        int neighbor = graph[node][i];
        if (neighbor != parent) {
            subtreeSum += dfs(neighbor, node, values, k, n);
        }
    }
    
    // If subtree sum is divisible by k, we can make it a separate component
    if (subtreeSum % k == 0) {
        components++;
        return 0; // This subtree is separated, contribute 0 to parent
    }
    
    return subtreeSum; // Return sum to parent
}

int maxKDivisibleComponents(int n, int edges[][2], int edgeCount, int* values, int k) {
    if (n == 1) {
        return values[0] % k == 0 ? 1 : 0;
    }
    
    // Initialize graph
    for (int i = 0; i < n; i++) {
        graphSize[i] = 0;
    }
    
    // Build adjacency list
    for (int i = 0; i < edgeCount; i++) {
        int u = edges[i][0], v = edges[i][1];
        graph[u][graphSize[u]++] = v;
        graph[v][graphSize[v]++] = u;
    }
    
    components = 0;
    dfs(0, -1, values, k, n);
    return components;
}

int main() {
    // Simplified input parsing for demonstration
    printf("DFS Optimal Solution\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single DFS traversal visiting each node once

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth up to n for skewed tree, plus adjacency list storage

⚡ Linearithmic Space

52.3K Views

Medium Frequency

~25 min Avg. Time

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

DFS with Subtree Sum (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler