Choose Edges to Maximize Score in a Tree - Problem

Choose Edges to Maximize Score in a Tree

Imagine you're a network engineer tasked with selecting optimal connections in a tree network to maximize bandwidth utilization. You have a weighted tree with n nodes numbered from 0 to n-1, rooted at node 0.

The tree structure is given as a 2D array edges where edges[i] = [parent_i, weight_i] indicates that parent_i is the parent of node i, and the edge between them has weight weight_i. The root node has edges[0] = [-1, -1] since it has no parent.

Your challenge: Select a subset of edges such that no two selected edges share a common node (are adjacent), and the sum of their weights is maximized.

Goal: Return the maximum possible sum of edge weights you can achieve.

Key constraint: Two edges are considered adjacent if they share any common node. For example, edges connecting (A↔B) and (B↔C) are adjacent because they both connect to node B.

Input & Output

example_1.py — Basic Tree

$ Input: edges = [[-1,-1],[0,5],[0,3],[1,4]]

› Output: 7

💡 Note: Tree structure: 0->1->3, 0->2. We can select edges (0,2) with weight 3 and (1,3) with weight 4. These edges don't share nodes, giving sum = 3 + 4 = 7.

example_2.py — Single Path

$ Input: edges = [[-1,-1],[0,2],[1,3],[2,1]]

› Output: 3

💡 Note: Linear tree: 0->1->2->3. We can only select one edge due to adjacency constraints. Choose edge (1,2) with weight 3 for maximum sum.

example_3.py — Single Node

$ Input: edges = [[-1,-1]]

› Output: 0

💡 Note: Tree with only root node has no edges to select, so maximum sum is 0.

Constraints

1 ≤ n ≤ 10⁵
edges.length == n
edges[i].length == 2
0 ≤ parent_i ≤ n - 1
-10⁶ ≤ weight_i ≤ 10⁶
edges[0] = [-1, -1]
The input represents a valid tree

Visualization

Tap to expand

Asked in

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

The optimal solution uses dynamic programming on trees with O(n) time complexity. For each node, we maintain two states: the maximum score when including the edge to its parent versus excluding it. The key insight is that including a parent edge prevents selecting any child edges due to adjacency constraints. This creates a perfect subproblem structure that DP can solve efficiently.

Common Approaches

✓ Stack

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

Brute Force (Try All Combinations)

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

Generate every possible subset of edges, check if any two edges in the subset are adjacent (share a node), and track the maximum sum among valid subsets.

Dynamic Programming on Tree (Optimal)

⏱️ Time: O(n) Space: O(n)

Apply dynamic programming on the tree structure. For each node, maintain two states: the maximum sum when including the edge to its parent, and when excluding it. The key insight is that if we include an edge to a node, we cannot include any edges to its children.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_N 100005

static int graph[MAX_N][100];  // Each node can have at most 100 children (reasonable for most trees)
static int graph_size[MAX_N];
static int edge_weights[MAX_N];  // Weight of edge from parent to this node
static int n;

typedef struct {
    long long include, exclude;
} Pair;

Pair dfs(int node, int parent) {
    long long includeEdge = 0;  // Sum when we include edge from parent to node
    long long excludeEdge = 0;  // Sum when we exclude edge from parent to node
    
    long long childrenExcludeSum = 0;  // Sum from children when we include parent edge
    long long childrenBestSum = 0;     // Sum from children when we exclude parent edge
    
    for (int i = 0; i < graph_size[node]; i++) {
        int child = graph[node][i];
        if (child == parent) {
            continue;
        }
        
        Pair childResult = dfs(child, node);
        childrenExcludeSum += childResult.exclude;  // Can't include child edges if we include parent edge
        childrenBestSum += (childResult.include > childResult.exclude) ? childResult.include : childResult.exclude;
    }
    
    if (parent != -1) {  // Not root
        includeEdge = edge_weights[node] + childrenExcludeSum;
    }
    
    excludeEdge = childrenBestSum;
    
    Pair result = {includeEdge, excludeEdge};
    return result;
}

long long solution(int edges[][2], int size) {
    n = size;
    if (n == 1) {
        return 0;
    }
    
    // Initialize
    for (int i = 0; i < n; i++) {
        graph_size[i] = 0;
        edge_weights[i] = 0;
    }
    
    // Build adjacency list
    for (int i = 1; i < n; i++) {
        int parent = edges[i][0];
        int weight = edges[i][1];
        
        graph[parent][graph_size[parent]++] = i;
        graph[i][graph_size[i]++] = parent;
        edge_weights[i] = weight;  // Store weight of edge from parent to node i
    }
    
    Pair result = dfs(0, -1);
    return result.exclude;
}

int main() {
    static char line[1000000];
    if (!fgets(line, sizeof(line), stdin)) {
        return 1;
    }
    
    // Count number of pairs
    int count = 0;
    char* ptr = line;
    while (*ptr) {
        if (*ptr == '[' && *(ptr+1) != '[') {  // Inner bracket, not outer
            count++;
        }
        ptr++;
    }
    
    static int edges[MAX_N][2];
    
    // Parse pairs
    ptr = line;
    int idx = 0;
    
    while (*ptr && idx < count) {
        if (*ptr == '[' && *(ptr+1) != '[') {  // Found start of a pair
            ptr++;  // Skip '['
            
            // Parse first number
            char* endptr;
            edges[idx][0] = (int)strtol(ptr, &endptr, 10);
            ptr = endptr;
            
            // Skip comma and whitespace
            while (*ptr && (*ptr == ',' || *ptr == ' ')) {
                ptr++;
            }
            
            // Parse second number
            edges[idx][1] = (int)strtol(ptr, &endptr, 10);
            ptr = endptr;
            
            // Skip to end of this pair
            while (*ptr && *ptr != ']') {
                ptr++;
            }
            if (*ptr == ']') {
                ptr++;
            }
            
            idx++;
        } else {
            ptr++;
        }
    }
    
    long long result = solution(edges, count);
    printf("%lld\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

⚡ Linearithmic Space

31.7K Views

Medium Frequency

~25 min Avg. Time

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