DP on Trees - Problem

Given a tree (connected acyclic graph) where each node has a positive integer weight, find the maximum weight independent set.

An independent set is a set of nodes where no two nodes are adjacent (directly connected by an edge). Your goal is to select nodes that maximize the total weight while ensuring no two selected nodes share an edge.

The tree is represented as an adjacency list where adj[i] contains all nodes connected to node i. Node weights are given in array weights where weights[i] is the weight of node i.

Input & Output

Example 1 — Linear Tree

$ Input: adj = [[1],[0,2],[1]], weights = [4,1,2]

› Output: 6

💡 Note: Tree structure: 0-1-2 with weights [4,1,2]. Optimal independent set is {0,2} with total weight 4+2=6. Node 1 is adjacent to both 0 and 2, so we can't include it with either.

Example 2 — Star Tree

$ Input: adj = [[1,2,3],[0],[0],[0]], weights = [1,4,4,4]

› Output: 12

💡 Note: Star tree with center 0 (weight=1) connected to leaves 1,2,3 (weights=4 each). Better to exclude center and take all leaves: 4+4+4=12 > 1.

Example 3 — Single Node

$ Input: adj = [[]], weights = [5]

› Output: 5

💡 Note: Tree with single node of weight 5. Only option is to include it, giving maximum weight 5.

Constraints

1 ≤ n ≤ 10⁴ where n is number of nodes
1 ≤ weights[i] ≤ 10⁴
The input represents a valid tree (connected and acyclic)
Nodes are numbered from 0 to n-1

Visualization

Tap to expand

Asked in

G Google 35 M Microsoft 28 a Amazon 22 F Facebook 18

The key insight is that for each node, we have two choices: include it (and exclude all adjacent nodes) or exclude it (and make optimal choices for adjacent nodes). The best approach uses tree DP with DFS traversal, computing include/exclude values for each subtree. Time: O(n), Space: O(n).

Common Approaches

✓ Bottom-Up DFS Traversal

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

Perform DFS traversal computing two values for each node: maximum weight if we include the node, and maximum weight if we exclude the node. Process children before parents to build solution bottom-up.

Brute Force - Try All Subsets

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

Generate all 2^n possible subsets of nodes, check if each subset has no adjacent nodes, and return the maximum weight valid subset. For each subset, we verify independence by checking if any two nodes share an edge.

Top-Down DP with Memoization

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

Use recursive approach where for each node we decide whether to include it (and exclude all children) or exclude it (and recursively solve for children). Memoization avoids recomputing the same subproblems.

Bottom-Up DFS Traversal — Algorithm Steps

Step 1: Start DFS from any node as root
Step 2: For leaf nodes, include = weight, exclude = 0
Step 3: For internal nodes, include = weight + sum(exclude of children)
Step 4: exclude = sum(max(include, exclude) of children)
Step 5: Return max(include, exclude) of root

Visualization

Tap to expand

Step-by-Step Walkthrough

Process Leaves

Start with leaf nodes: include=weight, exclude=0

Build Upward

For each internal node, compute include/exclude based on children

Root Decision

At root, choose maximum of include vs exclude scenarios

Code -

solution.c — C

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

void dfs(int node, int parent, int** adj, int* adjSizes, int* weights, int dp[][2]) {
    dp[node][0] = weights[node]; // include
    dp[node][1] = 0;             // exclude
    
    for (int i = 0; i < adjSizes[node]; i++) {
        int child = adj[node][i];
        if (child != parent) {
            dfs(child, node, adj, adjSizes, weights, dp);
            dp[node][0] += dp[child][1];
            dp[node][1] += (dp[child][0] > dp[child][1]) ? dp[child][0] : dp[child][1];
        }
    }
}

int solution(int** adj, int* adjSizes, int* weights, int n) {
    if (n == 0) return 0;
    
    int dp[1000][2];
    memset(dp, 0, sizeof(dp));
    
    dfs(0, -1, adj, adjSizes, weights, dp);
    return (dp[0][0] > dp[0][1]) ? dp[0][0] : dp[0][1];
}

int main() {
    int adj1[] = {1};
    int adj2[] = {0, 2};
    int adj3[] = {1};
    int* adj[] = {adj1, adj2, adj3};
    int adjSizes[] = {1, 2, 1};
    int weights[] = {4, 1, 2};
    int n = 3;
    
    int result = solution(adj, adjSizes, weights, n);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single DFS traversal visits each node once, constant work per node

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h, plus O(n) for storing DP values

✓ Linear Space

23.4K Views

Medium-High Frequency

~35 min Avg. Time

892 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

DP on Trees - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Bottom-Up DFS Traversal — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler