Maximum Profit from Trading Stocks with Discounts

Maximum Profit from Trading Stocks with Discounts - Problem

Imagine you're the chief investment officer at a company with a hierarchical structure where the CEO (employee 1) is at the top, and every other employee reports to someone up the chain. You have a unique opportunity to invest in employee stocks with an interesting twist!

You're given:

n employees, each with ID from 1 to n
present[i]: current price to buy employee i's stock today
future[i]: expected selling price tomorrow
hierarchy: boss-employee relationships
budget: total investment funds

The Discount Rule: If a boss buys their own stock, all their direct reports get a 50% discount on their stock price! 📈

Your goal is to maximize profit by strategically choosing which stocks to buy, considering both the discount opportunities and profit potential. Each stock can only be purchased once, and you must stay within budget.

Example: If Boss A (price $100, profit $20) has Employee B (price $80, profit $50), buying Boss A's stock makes Employee B's stock cost only $40, potentially increasing overall returns!

Input & Output

example_1.py — Basic Company Structure

$ Input: n = 3 present = [100, 80, 60] future = [150, 120, 90] hierarchy = [[1, 2], [1, 3]] budget = 200

› Output: 90

💡 Note: Optimal strategy: Buy stocks of employees 1 and 2. Employee 1 costs $100, profit = $50. Employee 2 gets 50% discount (since 1 is bought), costs $40, profit = $40. Total cost = $140, total profit = $90.

example_2.py — Multi-level Hierarchy

$ Input: n = 4 present = [120, 80, 60, 40] future = [150, 100, 90, 70] hierarchy = [[1, 2], [2, 3], [2, 4]] budget = 100

› Output: 50

💡 Note: Best strategy: Buy employee 2's stock ($80, profit $20) which gives discount to employees 3 and 4. Then buy employee 4's discounted stock ($20, profit $30). Total cost = $100, total profit = $50.

example_3.py — Limited Budget Edge Case

$ Input: n = 2 present = [100, 200] future = [110, 250] hierarchy = [[1, 2]] budget = 150

› Output: 10

💡 Note: With budget $150, we can only afford employee 1's stock ($100, profit $10). Employee 2's stock, even with 50% discount ($100), would exceed our remaining budget of $50.

Visualization

Tap to expand

Understanding the Visualization

Map the Hierarchy

Build the company tree structure showing boss-employee relationships

Identify Discount Opportunities

Mark which investments unlock 50% discounts for subordinates

Calculate Investment Options

For each employee, compute profit with and without discount

Apply Dynamic Programming

Use memoization to find optimal investment combinations

Maximize Returns

Select the strategy that yields highest profit within budget

Key Takeaway

🎯 Key Insight: The discount mechanism creates interdependencies between investment choices. Buying a manager's stock can unlock significant savings for their team, making seemingly expensive investments profitable when considering the collective benefit. Dynamic programming efficiently explores these complex decision trees to find the optimal strategy.

Time & Space Complexity

Time Complexity

⏱️

O(n × budget)

Each node-budget combination is computed once due to memoization

✓ Linear Growth

Space Complexity

O(n × budget)

Memoization table stores results for all node-budget pairs

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 1000
1 ≤ present[i], future[i] ≤ 10⁴
1 ≤ budget ≤ 10⁶
hierarchy.length = n - 1
Each employee has at most one direct boss
The hierarchy forms a valid tree structure
Employee 1 is always the root (CEO)

Asked in

GS Goldman Sachs 45 JPM JPMorgan Chase 38 ⊞ Microsoft 32 a Amazon 28 G Google 25

This problem combines tree traversal with dynamic programming to handle hierarchical discount dependencies. The optimal approach uses tree DP with memoization where each state represents (employee, remaining_budget, parent_discount_status). The key insight is that buying a boss's stock creates a cascade of 50% discounts for all direct reports, requiring careful consideration of investment order and budget allocation.

Common Approaches

Approach	Time	Space	Notes
✓ Tree DP with Memoization (Optimal)	O(n × budget)	O(n × budget)	Use dynamic programming on tree structure to find optimal investment strategy
Brute Force (Try All Combinations)	O(2^n)	O(n)	Try every possible subset of employees and calculate maximum profit

Tree DP with Memoization (Optimal) — Algorithm Steps

Build tree structure from hierarchy relationships
Define DP state: dp(node, budget) = maximum profit from subtree with given budget
For each node, try two choices: include it or exclude it
If included, children get discount; calculate profit accordingly
Use memoization to avoid recalculating same states

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Tree

Construct company hierarchy tree from boss-employee relationships

Define States

For each employee, track: (node, remaining_budget, parent_bought_stock)

Make Choices

At each node, decide: buy stock (enable discounts) or skip

Apply Discounts

If parent bought stock, children get 50% discount

Maximize Profit

Use memoization to efficiently find optimal profit combination

Code -

solution.c — C

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

#define MAX_N 100
#define MAX_BUDGET 10000

int memo[MAX_N][MAX_BUDGET][2];
int visited[MAX_N][MAX_BUDGET][2];
int children[MAX_N][MAX_N];
int childCount[MAX_N];
int present[MAX_N], future[MAX_N];

int dp(int node, int remainingBudget, int parentBought) {
    if (remainingBudget < 0) return -1000000;
    if (visited[node][remainingBudget][parentBought]) {
        return memo[node][remainingBudget][parentBought];
    }
    
    visited[node][remainingBudget][parentBought] = 1;
    int maxProfit = 0;
    
    // Option 1: Don't buy this stock
    for (int i = 0; i < childCount[node]; i++) {
        int child = children[node][i];
        int profit = dp(child, remainingBudget, 0);
        if (profit > maxProfit) maxProfit = profit;
    }
    
    // Option 2: Buy this stock
    int cost = present[node];
    if (parentBought) cost = cost / 2;
    
    if (cost <= remainingBudget) {
        int profitFromThis = future[node] - cost;
        int remaining = remainingBudget - cost;
        
        int childProfit = 0;
        for (int i = 0; i < childCount[node]; i++) {
            int child = children[node][i];
            int profit = dp(child, remaining, 1);
            if (profit > childProfit) childProfit = profit;
        }
        
        int totalProfit = profitFromThis + childProfit;
        if (totalProfit > maxProfit) maxProfit = totalProfit;
    }
    
    return memo[node][remainingBudget][parentBought] = maxProfit;
}

int maxProfit(int n, int* presentArr, int* futureArr, int** hierarchy, int hierarchySize, int budget) {
    // Initialize
    memset(visited, 0, sizeof(visited));
    memset(childCount, 0, sizeof(childCount));
    
    for (int i = 0; i < n; i++) {
        present[i] = presentArr[i];
        future[i] = futureArr[i];
    }
    
    int hasParent[MAX_N] = {0};
    for (int i = 0; i < hierarchySize; i++) {
        int boss = hierarchy[i][0] - 1;
        int emp = hierarchy[i][1] - 1;
        children[boss][childCount[boss]++] = emp;
        hasParent[emp] = 1;
    }
    
    // Find root
    int root = 0;
    for (int i = 0; i < n; i++) {
        if (!hasParent[i]) {
            root = i;
            break;
        }
    }
    
    return dp(root, budget, 0);
}

Time & Space Complexity

Time Complexity

⏱️

O(n × budget)

Each node-budget combination is computed once due to memoization

✓ Linear Growth

Space Complexity

O(n × budget)

Memoization table stores results for all node-budget pairs

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 1000
1 ≤ present[i], future[i] ≤ 10⁴
1 ≤ budget ≤ 10⁶
hierarchy.length = n - 1
Each employee has at most one direct boss
The hierarchy forms a valid tree structure
Employee 1 is always the root (CEO)

43.6K Views

Medium-High Frequency

~25 min Avg. Time

1.8K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Tree DP with Memoization (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler