Most Profitable Path in a Tree

Most Profitable Path in a Tree - Problem

There is an undirected tree with n nodes labeled from 0 to n - 1, rooted at node 0. You are given a 2D integer array edges of length n - 1 where edges[i] = [ai, bi] indicates that there is an edge between nodes ai and bi in the tree.

At every node i, there is a gate. You are also given an array of even integers amount, where amount[i] represents:

the price needed to open the gate at node i, if amount[i] is negative, or,
the cash reward obtained on opening the gate at node i, otherwise.

The game goes on as follows:

Initially, Alice is at node 0 and Bob is at node bob.
At every second, Alice and Bob each move to an adjacent node. Alice moves towards some leaf node, while Bob moves towards node 0.
For every node along their path, Alice and Bob either spend money to open the gate at that node, or accept the reward. Note that:

If the gate is already open, no price will be required, nor will there be any cash reward.
If Alice and Bob reach the node simultaneously, they share the price/reward for opening the gate there. In other words, if the price to open the gate is c, then both Alice and Bob pay c / 2 each. Similarly, if the reward at the gate is c, both of them receive c / 2 each.

If Alice reaches a leaf node, she stops moving. Similarly, if Bob reaches node 0, he stops moving. Note that these events are independent of each other.

Return the maximum net income Alice can have if she travels towards the optimal leaf node.

Input & Output

Example 1 — Basic Tree Structure

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

› Output: 6

💡 Note: Alice path: 0→1→3→4. At node 0: Alice gets -2. At node 1: Alice gets 4. At node 3: Bob starts here at t=0, Alice arrives at t=2, so Alice gets full -4. At node 4: Alice gets 6. Total: -2+4+(-4)+6 = 4. But Alice can also go 0→1→2 for total -2+4+2 = 4. Actually, the optimal is when Alice goes to leaf 4, getting total income 6.

Example 2 — Sharing Scenario

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

› Output: -2465

💡 Note: Alice goes 0→1. At node 0: Alice gets -7280. At node 1: Bob starts here, Alice arrives at t=1, Bob reaches root at t=1, but Bob is moving toward node 0, so they don't meet. Alice gets full 2350. Total: -7280+2350 = -4930. Actually, they meet at different times so Alice gets the amounts based on timing.

Example 3 — Multiple Paths

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

› Output: 400

💡 Note: Alice can go 0→1 (total 100+(-200)=-100) or 0→2. If Alice goes 0→2: At node 0, Alice gets 100. At node 2, Bob starts here but Alice arrives at t=1, and Bob moves toward 0, so timing determines sharing. Alice path 0→2 gives better income.

Constraints

1 ≤ n ≤ 10⁵
edges.length == n - 1
0 ≤ ai, bi < n
ai ≠ bi
edges represents a valid tree
1 ≤ bob < n
amount.length == n
-10⁴ ≤ amount[i] ≤ 10⁴
amount[i] is even

Visualization

Tap to expand

Asked in

G Google 12 a Amazon 8 M Microsoft 6

The key insight is to pre-compute Bob's path timing using BFS, then use DFS to explore Alice's paths with O(1) conflict resolution. The optimal approach runs in O(n) time by avoiding redundant path calculations. Best approach: Optimized DFS with pre-computed Bob timeline. Time: O(n), Space: O(n)

Common Approaches

✓ Brute Force DFS

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

For each leaf node, calculate Alice's path and simulate Bob's movement step by step. Check for conflicts and calculate shared rewards.

Optimized DFS with Pre-computed Bob Path

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

First find Bob's path to root with BFS and store timing information. Then use DFS to explore Alice's paths with O(1) conflict checking.

Brute Force DFS — Algorithm Steps

Step 1: Build adjacency list from edges
Step 2: For each leaf node, run DFS to calculate Alice's income
Step 3: Simulate Bob's movement and handle conflicts
Step 4: Return maximum income across all paths

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Graph

Create adjacency list from edges

Find Bob's Path

Calculate Bob's path timing to root

DFS All Paths

Explore every path Alice can take

Calculate Income

Handle sharing when Alice and Bob meet

Code -

solution.c — C

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

#define MAX_N 10000

static int graph[MAX_N][MAX_N];
static int graphSize[MAX_N];
static int bobTime[MAX_N];
static int hasBobTime[MAX_N];
static int amount[MAX_N];
static int n;
static int maxIncome;

void dfs(int node, int parent, int time, int income) {
    // Calculate income at current node
    int currentIncome = income;
    if (hasBobTime[node] && bobTime[node] == time) {
        // Share the amount
        currentIncome += amount[node] / 2;
    } else if (!hasBobTime[node] || bobTime[node] > time) {
        // Alice gets full amount (Bob hasn't been here or comes later)
        currentIncome += amount[node];
    }
    // If Bob reached this node before Alice (bob_time[node] < time), Alice gets 0
    
    // Check if this is a leaf node (or if we've reached a dead end)
    int childrenCount = 0;
    for (int i = 0; i < graphSize[node]; i++) {
        int neighbor = graph[node][i];
        if (neighbor != parent) {
            childrenCount++;
        }
    }
    if (childrenCount == 0) {
        if (currentIncome > maxIncome) {
            maxIncome = currentIncome;
        }
        return;
    }
    
    // Continue to children
    for (int i = 0; i < graphSize[node]; i++) {
        int neighbor = graph[node][i];
        if (neighbor != parent) {
            dfs(neighbor, node, time + 1, currentIncome);
        }
    }
}

int solution(int edges[][2], int edgeCount, int bob, int* amt, int amtSize) {
    n = amtSize;
    maxIncome = INT_MIN;
    
    memset(graphSize, 0, sizeof(graphSize));
    memset(hasBobTime, 0, sizeof(hasBobTime));
    
    for (int i = 0; i < amtSize; i++) {
        amount[i] = amt[i];
    }
    
    // Build adjacency list
    for (int i = 0; i < edgeCount; i++) {
        int a = edges[i][0], b = edges[i][1];
        graph[a][graphSize[a]++] = b;
        graph[b][graphSize[b]++] = a;
    }
    
    // Find Bob's path from bob to 0
    int bobPath[MAX_N];
    int bobPathLen = 0;
    
    // BFS to find path
    static int queue[MAX_N][MAX_N];
    static int queueLen[MAX_N];
    int visited[MAX_N] = {0};
    int front = 0, rear = 0;
    
    queue[rear][0] = bob;
    queueLen[rear] = 1;
    rear++;
    visited[bob] = 1;
    
    while (front < rear) {
        int* path = queue[front];
        int pathLen = queueLen[front];
        front++;
        
        int node = path[pathLen - 1];
        if (node == 0) {
            for (int i = 0; i < pathLen; i++) {
                bobPath[i] = path[i];
                bobTime[path[i]] = i;
                hasBobTime[path[i]] = 1;
            }
            bobPathLen = pathLen;
            break;
        }
        
        for (int i = 0; i < graphSize[node]; i++) {
            int neighbor = graph[node][i];
            if (!visited[neighbor]) {
                visited[neighbor] = 1;
                for (int j = 0; j < pathLen; j++) {
                    queue[rear][j] = path[j];
                }
                queue[rear][pathLen] = neighbor;
                queueLen[rear] = pathLen + 1;
                rear++;
            }
        }
    }
    
    // Handle the starting node (node 0)
    int startIncome = 0;
    if (hasBobTime[0] && bobTime[0] == 0) {
        startIncome = amount[0] / 2;
    } else if (!hasBobTime[0] || bobTime[0] > 0) {
        startIncome = amount[0];
    }
    
    // Check if node 0 is itself a leaf (only possible if n=1)
    if (graphSize[0] == 0) {
        return startIncome;
    }
    
    // Start DFS from node 0's children
    for (int i = 0; i < graphSize[0]; i++) {
        int neighbor = graph[0][i];
        dfs(neighbor, 0, 1, startIncome);
    }
    
    return maxIncome;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[100000];
    fgets(line, sizeof(line), stdin);
    
    static int edges[MAX_N][2];
    int edgeCount = 0;
    
    char* ptr = line + 1;
    while (*ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            edges[edgeCount][0] = atoi(ptr);
            while (*ptr != ',') ptr++;
            ptr++;
            edges[edgeCount][1] = atoi(ptr);
            edgeCount++;
            while (*ptr != ']') ptr++;
            ptr++;
        } else {
            ptr++;
        }
    }
    
    int bob;
    scanf("%d", &bob);
    
    fgets(line, sizeof(line), stdin);
    fgets(line, sizeof(line), stdin);
    
    static int amount[MAX_N];
    int amtSize;
    parseArray(line, amount, &amtSize);
    
    printf("%d\n", solution(edges, edgeCount, bob, amount, amtSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n nodes, we might traverse the entire tree

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth and adjacency list storage

⚡ Linearithmic Space

15.4K Views

Medium Frequency

~25 min Avg. Time

487 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 DFS — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler