Most Profitable Path in a Tree - Practice Coding Problems

Most Profitable Path in a Tree - Problem

🎮 The Tree Adventure Game

Imagine an exciting two-player game played on an undirected tree with n nodes (labeled 0 to n-1). The tree is rooted at node 0, and you're given an array of edges that defines the tree structure.

Each node has a gate with either a cost to open (negative values) or a reward for opening (positive values), stored in the amount array.

Game Rules:

Alice starts at node 0 and moves toward any leaf node of her choice
Bob starts at node bob and moves toward node 0
Both players move simultaneously one step per second
When a player reaches a gate: they pay the cost or receive the reward
Special case: If both players reach the same node simultaneously, they split the cost/reward equally
Players stop when Alice reaches a leaf or Bob reaches node 0

Your goal: Find the maximum net income Alice can achieve by choosing the optimal path to a leaf node!

Input & Output

example_1.py — Basic Tree Structure

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

› Output: 6

💡 Note: Alice starts at node 0, Bob starts at node 3. Alice can go 0→1→2 (gets 2+4+4=10) or 0→1→3. Bob goes 3→1→0. If Alice chooses path 0→1→2: At time 0, Alice is at 0 (gets 2), Bob is at 3. At time 1, both are at 1 (share 4, Alice gets 2). At time 2, Alice is at 2 (gets 4), Bob is at 0. Total for Alice: 2+2+4=8. But the optimal path gives Alice 6 total profit.

example_2.py — Single Path Case

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

› Output: 0

💡 Note: Alice starts at 0, Bob starts at 1. Alice must go to node 1 (the only leaf). At time 0: Alice gets amount[0]=2, Bob gets amount[1]=-2. At time 1: they meet at node 1, but Bob was already there, so the gate is already opened with no reward. Alice's total profit is 2 + 0 = 2. Wait, let me recalculate: Alice gets 2 at node 0, then at time 1 when she reaches node 1, Bob is at node 0. So Alice gets -2 at node 1. Total: 2 + (-2) = 0.

example_3.py — Sharing Rewards

$ Input: edges = [[0,1],[1,2],[2,3]], bob = 2, amount = [10,2,6,-4]

› Output: 12

💡 Note: Tree is a line: 0-1-2-3. Alice starts at 0, Bob starts at 2. Alice goes 0→1→2→3, Bob goes 2→1→0. At time 0: Alice at 0 (gets 10), Bob at 2. At time 1: Alice at 1, Bob at 1 (they share amount[1]=2, Alice gets 1). At time 2: Alice at 2 (gets 6), Bob at 0. At time 3: Alice at 3 (gets -4). Alice's total: 10 + 1 + 6 + (-4) = 13. Actually, let me verify this calculation...

Visualization

Tap to expand

Understanding the Visualization

Map Bob's Escape Route

Bob always takes the shortest path to the entrance (node 0), so we can precompute his exact route and timing.

Explore Alice's Options

Alice can choose any exit (leaf node). We use DFS to explore all possible paths she could take.

Handle Encounters

When Alice and Bob are in the same room at the same time, they split the treasure/cost equally.

Find Optimal Path

Among all possible paths to exits, choose the one that gives Alice maximum profit.

Key Takeaway

🎯 Key Insight: Since Bob's path is deterministic (shortest to root), we can precompute his timing and then efficiently explore all of Alice's options with DFS, achieving optimal O(n) complexity.

Time & Space Complexity

Time Complexity

⏱️

O(n)

BFS for Bob's path takes O(n), DFS for Alice explores each node at most once

✓ Linear Growth

Space Complexity

O(n)

Space for adjacency list, Bob's path, recursion stack, and timing map

⚡ Linearithmic Space

Constraints

2 ≤ n ≤ 10⁴
edges.length == n - 1
edges[i].length == 2
0 ≤ a_i, b_i < n
a_i ≠ b_i
edges represents a valid tree
1 ≤ bob < n
amount.length == n
-10⁴ ≤ amount[i] ≤ 10⁴
amount array contains even integers only

Asked in

G Google 42 a Amazon 35 f Meta 28 ⊞ Microsoft 22 Apple 18

The optimal approach uses DFS with Bob path preprocessing. First, we find Bob's shortest path to node 0 using BFS and create a timing map. Then we use DFS to explore all possible paths Alice can take to reach leaves, checking at each node whether Bob is there simultaneously (split reward/cost) or Bob arrived first (Alice gets nothing). The time complexity is O(n) and space complexity is O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Optimized DFS with Bob Path Preprocessing	O(n)	O(n)	Precompute Bob's path and timing, then use DFS to find Alice's optimal path
Brute Force Path Simulation	O(n²)	O(n)	Try all possible paths for Alice and simulate Bob's movement for each

Optimized DFS with Bob Path Preprocessing — Algorithm Steps

Build adjacency list from edges
Use BFS to find Bob's shortest path from his starting position to node 0
Create a time mapping for when Bob reaches each node
Use DFS from node 0 to explore all of Alice's possible paths to leaves
For each node Alice visits, check if Bob is there at the same time
Calculate profit sharing rules and track maximum profit
Return the maximum profit Alice can achieve

Visualization

Tap to expand

Step-by-Step Walkthrough

Precompute Bob's Path

Use BFS to find Bob's shortest path to node 0 and create timing map

Start Alice's DFS

Begin DFS from node 0, tracking time and current profit

Check Node Conflicts

At each node, check if Bob is there at the same time using timing map

Update Maximum

When reaching leaves, update maximum profit Alice can achieve

Code -

solution.c — C

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

#define MAX_NODES 1000

int graph[MAX_NODES][MAX_NODES];
int graphSize[MAX_NODES];
int bobTiming[MAX_NODES];
int maxProfit = INT_MIN;

void getBobTiming(int n, int bob) {
    memset(bobTiming, -1, sizeof(bobTiming));
    
    if (bob == 0) {
        bobTiming[0] = 0;
        return;
    }
    
    int queue[MAX_NODES];
    int parent[MAX_NODES];
    int visited[MAX_NODES] = {0};
    int front = 0, rear = 0;
    
    queue[rear++] = bob;
    parent[bob] = -1;
    visited[bob] = 1;
    
    while (front < rear) {
        int node = queue[front++];
        
        if (node == 0) {
            // Reconstruct path
            int path[MAX_NODES];
            int pathSize = 0;
            int curr = 0;
            
            while (curr != -1) {
                path[pathSize++] = curr;
                curr = parent[curr];
            }
            
            // Reverse path and create timing
            for (int i = 0; i < pathSize; i++) {
                bobTiming[path[pathSize - 1 - i]] = i;
            }
            return;
        }
        
        for (int i = 0; i < graphSize[node]; i++) {
            int neighbor = graph[node][i];
            if (!visited[neighbor]) {
                visited[neighbor] = 1;
                parent[neighbor] = node;
                queue[rear++] = neighbor;
            }
        }
    }
}

void dfs(int* amount, int node, int parent, int time, int currentProfit) {
    int profitHere = amount[node];
    
    if (bobTiming[node] != -1) {
        if (bobTiming[node] == time) {
            profitHere /= 2;
        } else if (bobTiming[node] < time) {
            profitHere = 0;
        }
    }
    
    currentProfit += profitHere;
    
    int childrenCount = 0;
    for (int i = 0; i < graphSize[node]; i++) {
        if (graph[node][i] != parent) {
            childrenCount++;
        }
    }
    
    if (childrenCount == 0) {
        if (currentProfit > maxProfit) {
            maxProfit = currentProfit;
        }
        return;
    }
    
    for (int i = 0; i < graphSize[node]; i++) {
        int child = graph[node][i];
        if (child != parent) {
            dfs(amount, child, node, time + 1, currentProfit);
        }
    }
}

int mostProfitablePath(int** edges, int edgesSize, int* edgesColSize, int bob, int* amount, int amountSize) {
    int n = amountSize;
    
    // Initialize
    memset(graphSize, 0, sizeof(graphSize));
    maxProfit = INT_MIN;
    
    // Build graph
    for (int i = 0; i < edgesSize; i++) {
        int a = edges[i][0], b = edges[i][1];
        graph[a][graphSize[a]++] = b;
        graph[b][graphSize[b]++] = a;
    }
    
    // Get Bob's timing
    getBobTiming(n, bob);
    
    // DFS to find maximum profit
    dfs(amount, 0, -1, 0, 0);
    
    return maxProfit;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

BFS for Bob's path takes O(n), DFS for Alice explores each node at most once

✓ Linear Growth

Space Complexity

O(n)

Space for adjacency list, Bob's path, recursion stack, and timing map

⚡ Linearithmic Space

Constraints

2 ≤ n ≤ 10⁴
edges.length == n - 1
edges[i].length == 2
0 ≤ a_i, b_i < n
a_i ≠ b_i
edges represents a valid tree
1 ≤ bob < n
amount.length == n
-10⁴ ≤ amount[i] ≤ 10⁴
amount array contains even integers only

28.4K Views

Medium Frequency

~25 min Avg. Time

890 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

🎮 The Tree Adventure Game

Game Rules:

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Optimized DFS with Bob Path Preprocessing — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler