Maximum Good Subtree Score

Maximum Good Subtree Score - Problem

Array Dynamic Programming Bit Manipulation Tree Depth-First Search Bitmask Hard

You're exploring a family tree where each person has a unique value, and you want to find the most valuable group from each family branch with one special rule: no digit (0-9) can appear more than once across all the values in your selected group.

Given an undirected tree rooted at node 0 with n nodes numbered from 0 to n-1, each node i has an integer value vals[i]. A good subset within any subtree means every digit from 0 to 9 appears at most once in the decimal representation of all selected node values combined.

Your goal: For each node u, find the maximum possible sum of a good subset from its subtree (including itself and all descendants). Return the sum of all these maximum values modulo 10⁹ + 7.

Example: If a subtree has nodes with values [123, 456, 789], this is good because digits 1,2,3,4,5,6,7,8,9 each appear once. But [123, 124] would not be good because digit '2' appears twice.

Input & Output

example_1.py — Simple Tree

$ Input: vals = [1, 2, 3, 4], par = [0, 0, 1, 1]

› Output: 26

💡 Note: Tree structure: 0(1) has children 1(2), 1(2) has children 2(3) and 3(4). For subtree at 0: best subset is {1,2,3,4} with no repeated digits, sum=10. For subtree at 1: best is {2,3,4}, sum=9. For subtree at 2: {3} sum=3. For subtree at 3: {4} sum=4. Total: 10+9+3+4=26.

example_2.py — Digit Conflict

$ Input: vals = [12, 23, 34], par = [0, 0, 1]

› Output: 114

💡 Note: Tree: 0(12) -> 1(23) -> 2(34). Node 0's subtree can use {12,34} (digits 1,2,3,4 - valid) sum=46. Node 1's subtree: {23,34} have conflicting digit 3, so max is {34}=34. Node 2: {34}=34. Total: 46+34+34=114.

example_3.py — Single Node

$ Input: vals = [100], par = [0]

› Output: 100

💡 Note: Only one node with value 100. The only subtree (rooted at 0) has maximum score 100. Total sum = 100.

Constraints

1 ≤ n ≤ 10³
0 ≤ vals[i] ≤ 10⁹
par[0] = 0 (root has itself as parent)
0 ≤ par[i] < i for 1 ≤ i < n
Tree structure guaranteed - no cycles, connected

Visualization

Tap to expand

Asked in

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

The optimal solution uses dynamic programming with bitmasks to efficiently track digit usage across subtrees. Key insights: (1) Convert each value to a 10-bit mask representing its digits, (2) Use post-order DFS to process children first, (3) For each node, maintain DP states mapping digit masks to maximum scores, (4) Combine compatible states from children and current node. Time complexity: O(n × 2¹⁰) since there are only 1024 possible digit combinations, much better than the brute force O(n × 2ⁿ) approach.

Common Approaches

✓ Sort First

⏱️ Time: N/A Space: N/A

Binary Search Answer

⏱️ Time: N/A Space: N/A

Brute Force (All Subsets)

⏱️ Time: O(n * 2^n) Space: O(n)

For each node, generate all possible subsets of its subtree, check if each subset satisfies the digit uniqueness constraint, and find the maximum sum. This approach explores every combination exhaustively.

Dynamic Programming with Bitmask (Optimal)

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

This optimal approach uses dynamic programming with bitmasks to represent which digits are used. We perform a post-order DFS traversal, computing the maximum score for each subtree by considering all valid combinations of digit usage patterns from child subtrees.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int abs_val(int x) {
    return x < 0 ? -x : x;
}

int max_val(int a, int b) {
    return a > b ? a : b;
}

typedef struct {
    int dist;
    int count;
    int indices[1000];
} DistGroup;

int compare_dist(const void *a, const void *b) {
    DistGroup *da = (DistGroup*)a;
    DistGroup *db = (DistGroup*)b;
    return da->dist - db->dist;
}

int solution(int points[][2], int n, char* s) {
    if (n == 0) return 0;
    
    // Group points by distance
    DistGroup groups[1000];
    int groupCount = 0;
    
    for (int i = 0; i < n; i++) {
        int dist = max_val(abs_val(points[i][0]), abs_val(points[i][1]));
        
        // Find existing group or create new one
        int groupIdx = -1;
        for (int j = 0; j < groupCount; j++) {
            if (groups[j].dist == dist) {
                groupIdx = j;
                break;
            }
        }
        
        if (groupIdx == -1) {
            groups[groupCount].dist = dist;
            groups[groupCount].count = 0;
            groupIdx = groupCount++;
        }
        
        groups[groupIdx].indices[groups[groupIdx].count++] = i;
    }
    
    // Sort groups by distance
    qsort(groups, groupCount, sizeof(DistGroup), compare_dist);
    
    bool tagsSeen[256] = {false};
    int maxPoints = 0;
    
    for (int g = 0; g < groupCount; g++) {
        // Check if we can add all points in this group
        bool canAddAll = true;
        bool newTags[256] = {false};
        
        for (int i = 0; i < groups[g].count; i++) {
            int idx = groups[g].indices[i];
            unsigned char tag = (unsigned char)s[idx];
            if (tagsSeen[tag] || newTags[tag]) {
                canAddAll = false;
                break;
            }
            newTags[tag] = true;
        }
        
        if (canAddAll) {
            // Add all points in this group
            for (int i = 0; i < groups[g].count; i++) {
                int idx = groups[g].indices[i];
                tagsSeen[(unsigned char)s[idx]] = true;
            }
            
            // Count total points
            int count = 0;
            for (int i = 0; i < 256; i++) {
                if (tagsSeen[i]) count++;
            }
            maxPoints = count;
        } else {
            // Cannot expand further while maintaining validity
            break;
        }
    }
    
    return maxPoints;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse points array
    int points[1000][2];
    int n = 0;
    char *token = strtok(line, "[],");
    while (token != NULL && n < 2000) {
        if (strlen(token) > 0 && token[0] != '\n' && token[0] != ' ') {
            points[n/2][n%2] = atoi(token);
            n++;
        }
        token = strtok(NULL, "[],");
    }
    n /= 2;
    
    char s[1001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    int result = solution(points, n, s);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

36.2K Views

Medium-High 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