Choose Edges to Maximize Score in a Tree - Practice Coding Problems

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

Understanding the Visualization

Identify the Tree Structure

Parse the parent-child relationships to build the tree representation

Define the Choice at Each Node

For each node, decide whether to include the edge to its parent

Apply the Constraint

If we include a parent edge, we cannot include any child edges

Optimize with DP

Use dynamic programming to efficiently compute the optimal choice for each subtree

Key Takeaway

🎯 Key Insight: Transform the edge selection problem into a node-based DP where each node decides whether to include its parent edge, naturally handling the adjacency constraint through the tree structure.

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

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(2^n × n²)	O(n)	Generate all possible edge combinations and check adjacency constraints
Dynamic Programming on Tree (Optimal)	O(n)	O(n)	Use tree DP with two states per node: include/exclude parent edge

Brute Force (Try All Combinations) — Algorithm Steps

Build adjacency representation of the tree
Generate all 2^(n-1) possible edge subsets using bit manipulation
For each subset, check if any two edges share a common node
If valid (no adjacent edges), calculate sum and update maximum
Return the maximum sum found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subsets

Create all 2^(n-1) possible edge combinations using bit manipulation

Check Adjacency

For each subset, verify no two edges share a common node

Track Maximum

Keep track of the maximum sum among valid subsets

Code -

solution.c — C

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

typedef struct {
    int u, v, weight;
} Edge;

int maxScore(int** edges, int edgesSize, int* edgesColSize) {
    if (edgesSize <= 1) return 0;
    
    Edge* edgeList = (Edge*)malloc(edgesSize * sizeof(Edge));
    int edgeCount = 0;
    
    for (int i = 1; i < edgesSize; i++) {
        if (edges[i][0] != -1) {
            edgeList[edgeCount++] = (Edge){edges[i][0], i, edges[i][1]};
        }
    }
    
    if (edgeCount == 0) {
        free(edgeList);
        return 0;
    }
    
    int maxSum = 0;
    
    for (int mask = 0; mask < (1 << edgeCount); mask++) {
        Edge* currentEdges = (Edge*)malloc(edgeCount * sizeof(Edge));
        int currentCount = 0;
        int currentSum = 0;
        
        for (int i = 0; i < edgeCount; i++) {
            if (mask & (1 << i)) {
                currentEdges[currentCount++] = edgeList[i];
                currentSum += edgeList[i].weight;
            }
        }
        
        bool valid = true;
        for (int i = 0; i < currentCount && valid; i++) {
            for (int j = i + 1; j < currentCount; j++) {
                if (currentEdges[i].u == currentEdges[j].u ||
                    currentEdges[i].u == currentEdges[j].v ||
                    currentEdges[i].v == currentEdges[j].u ||
                    currentEdges[i].v == currentEdges[j].v) {
                    valid = false;
                    break;
                }
            }
        }
        
        if (valid && currentSum > maxSum) {
            maxSum = currentSum;
        }
        
        free(currentEdges);
    }
    
    free(edgeList);
    return maxSum;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n × n²)

2^n subsets to check, each requiring O(n²) adjacency validation

⚠ Quadratic Growth

Space Complexity

O(n)

Space for adjacency list and current subset tracking

⚡ 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler