Difference Between Maximum and Minimum Price Sum

Difference Between Maximum and Minimum Price Sum - Problem

Imagine you're a network architect tasked with optimizing the cost efficiency of a tree-structured network with n nodes (indexed 0 to n-1). You have an unrooted tree defined by edges array, where each edge connects two nodes, and each node has an associated operational price.

The price sum of any path is simply the sum of prices of all nodes along that path. Here's the challenge: you can choose any node as the root of your network. Once you pick a root, you need to consider all possible paths that start from this root node.

The incurred cost for choosing a particular root is the difference between the maximum and minimum price sum among all paths starting from that root. Your goal is to find the maximum possible cost you can achieve by choosing the optimal root.

This problem combines tree traversal, dynamic programming, and optimal substructure - making it a fascinating challenge that tests your ability to think about tree rerooting and path optimization!

Input & Output

example_1.py — Basic Tree

$ Input: n = 4, edges = [[0,1],[1,2],[1,3]], price = [2,3,6,5]

› Output: 6

💡 Note: When root is node 1, paths are: [1]→[0] (sum=5), [1]→[2] (sum=9), [1]→[3] (sum=8). Max=9, Min=3, difference=6. This is optimal.

example_2.py — Linear Chain

$ Input: n = 3, edges = [[0,1],[1,2]], price = [1,4,2]

› Output: 5

💡 Note: When root is node 1, paths are: [1]→[0] (sum=5) and [1]→[2] (sum=6). Difference = 6-5 = 1. When root is 0 or 2, we get larger differences.

example_3.py — Single Node

$ Input: n = 1, edges = [], price = [5]

› Output: 0

💡 Note: Only one node exists, so there's only one path with sum=5. Max=Min=5, so difference=0.

Constraints

1 ≤ n ≤ 2 × 10⁴
edges.length == n - 1
0 ≤ a_i, b_i ≤ n - 1
edges represents a valid tree
1 ≤ price[i] ≤ 10⁵
The graph is guaranteed to be a connected tree

Visualization

Tap to expand

Understanding the Visualization

Original Tree

Start with an unrooted tree where each node has a price

Root Choice 1

Choose node 0 as root and calculate all path sums from this root

Root Choice 2

Choose node 1 as root and recalculate - notice how paths change

Optimize

Use DP to avoid recalculating everything when changing roots

Final Answer

Find the root that gives maximum difference between max and min paths

Key Takeaway

🎯 Key Insight: Different root choices create different path structures. The optimal approach uses dynamic programming with tree rerooting to efficiently explore all possibilities in O(n) time rather than the naive O(n²) approach.

Asked in

G Google 23 f Meta 18 a Amazon 15 ⊞ Microsoft 12

This problem requires finding the optimal root in a tree to maximize the difference between maximum and minimum path sums. The optimal approach uses dynamic programming with tree rerooting technique. First, calculate subtree information in O(n), then use rerooting to efficiently compute the answer for each possible root in another O(n) pass, achieving overall O(n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try Every Root)	O(n²)	O(n)	Try every node as root and calculate all path sums using DFS
Two-Pass Dynamic Programming	O(n)	O(n)	First pass: calculate subtree info, second pass: reroot and find optimal costs

Brute Force (Try Every Root) — Algorithm Steps

Iterate through each node as a potential root
For each root, perform DFS to find all paths starting from root
Calculate price sum for each path
Find maximum and minimum price sums
Calculate difference (max - min) as the cost for this root
Track the maximum cost across all root choices

Visualization

Tap to expand

Step-by-Step Walkthrough

Choose Root

Select a node as the root candidate

DFS Paths

Perform DFS to find all paths from root to leaves

Calculate Sums

Sum the prices along each path

Find Min/Max

Identify minimum and maximum path sums

Compute Cost

Calculate difference (max - min)

Track Maximum

Keep track of the best cost found so far

Code -

solution.c — C

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

#define MAX_N 1000

int graph[MAX_N][MAX_N];
int graphSize[MAX_N];
int price[MAX_N];
long long paths[MAX_N];
int pathCount;

void dfsPath(int node, int parent, long long currentSum, int n) {
    currentSum += price[node];
    
    int isLeaf = 1;
    for (int i = 0; i < graphSize[node]; i++) {
        int neighbor = graph[node][i];
        if (neighbor != parent) {
            isLeaf = 0;
            dfsPath(neighbor, node, currentSum, n);
        }
    }
    
    if (isLeaf) {
        paths[pathCount++] = currentSum;
    }
}

long long maxOutput(int n, int edges[][2], int edgeCount, int prices[]) {
    // Initialize graph
    for (int i = 0; i < n; i++) {
        graphSize[i] = 0;
        price[i] = prices[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;
    }
    
    long long maxCost = 0;
    
    for (int root = 0; root < n; root++) {
        pathCount = 0;
        dfsPath(root, -1, 0, n);
        
        if (pathCount > 0) {
            long long maxSum = LLONG_MIN;
            long long minSum = LLONG_MAX;
            
            for (int i = 0; i < pathCount; i++) {
                if (paths[i] > maxSum) maxSum = paths[i];
                if (paths[i] < minSum) minSum = paths[i];
            }
            
            long long cost = maxSum - minSum;
            if (cost > maxCost) {
                maxCost = cost;
            }
        }
    }
    
    return maxCost;
}

int main() {
    // Parse input implementation needed
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n nodes as root, we traverse the entire tree to find all paths

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth and space to store the tree structure

⚡ Linearithmic Space

27.5K Views

Medium 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Try Every Root) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler