Maximum Profit from Trading Stocks with Discounts - Problem

You are given an integer n, representing the number of employees in a company. Each employee is assigned a unique ID from 1 to n, and employee 1 is the CEO who is the direct or indirect boss of every employee.

You are given two 1-based integer arrays, present and future, each of length n, where:

present[i] represents the current price at which the i-th employee can buy a stock today
future[i] represents the expected price at which the i-th employee can sell the stock tomorrow

The company's hierarchy is represented by a 2D integer array hierarchy, where hierarchy[i] = [u_i, v_i] means that employee u_i is the direct boss of employee v_i.

Additionally, you have an integer budget representing the total funds available for investment.

Discount Policy: If an employee's direct boss purchases their own stock, then the employee can buy their stock at half the original price (floor(present[v] / 2)).

Return the maximum profit that can be achieved without exceeding the given budget.

Note: You may buy each stock at most once. You cannot use any profit earned from future stock prices to fund additional investments and must buy only from budget.

Input & Output

Example 1 — Basic Hierarchy

$ Input: n = 3, present = [10,5,3], future = [15,8,7], hierarchy = [[1,2],[1,3]], budget = 15

› Output: 9

💡 Note: Buy CEO's stock (cost 10, profit 5) and Employee 3's stock (cost 1 with discount, profit 4). Total cost: 11, total profit: 9

Example 2 — Limited Budget

$ Input: n = 3, present = [20,10,5], future = [25,15,10], hierarchy = [[1,2],[1,3]], budget = 10

› Output: 5

💡 Note: Can only buy Employee 3's stock (cost 5, profit 5). CEO's stock is too expensive.

Example 3 — Maximum Discount

$ Input: n = 2, present = [8,6], future = [12,10], hierarchy = [[1,2]], budget = 10

› Output: 4

💡 Note: Can only buy Employee 2's stock (cost 6, profit 4) within budget. CEO + discounted Employee 2 would cost 11 > 10.

Constraints

1 ≤ n ≤ 1000
1 ≤ present[i], future[i] ≤ 10⁴
1 ≤ budget ≤ 10⁵
hierarchy.length = n - 1

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 f Meta 6

This problem combines tree traversal with dynamic programming and knapsack-like optimization. The key insight is that each employee's purchase decision affects their subordinates' costs through the discount policy. The optimal approach uses memoized tree DP to explore buy/don't-buy decisions while considering budget constraints and discount cascading. Time: O(n × budget), Space: O(n × budget).

Common Approaches

✓ Brute Force - Try All Combinations

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

Try every possible subset of employees to buy stocks from, considering discount rules. For each combination, calculate total cost and profit, keeping track of the maximum profit within budget.

Memoized Tree DP

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

Build the company hierarchy as a tree and use dynamic programming with memoization. For each employee, calculate the maximum profit considering whether to buy their stock or not, with discounts from boss purchases.

Brute Force - Try All Combinations — Algorithm Steps

Generate all 2^n possible combinations of stock purchases
For each combination, calculate discounted prices based on hierarchy
Check if total cost is within budget and calculate profit
Return maximum profit found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Combinations

Create all 2^n possible purchase combinations

Check Each Combo

Calculate cost and profit considering discounts

Find Maximum

Return highest profit within budget

Code -

solution.c — C

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

int solution(int n, int* present, int* future, int hierarchy[][2], int hierarchySize, int budget) {
    int maxProfit = 0;
    
    // Try all possible combinations using bitmask
    for (int mask = 0; mask < (1 << n); mask++) {
        int totalCost = 0;
        int totalProfit = 0;
        int valid = 1;
        
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                int employee = i + 1;
                // Check if boss bought stock (for discount)
                int bossBought = 0;
                for (int j = 0; j < hierarchySize; j++) {
                    if (hierarchy[j][1] == employee && (mask & (1 << (hierarchy[j][0] - 1)))) {
                        bossBought = 1;
                        break;
                    }
                }
                
                // Calculate cost with potential discount
                int cost = bossBought ? present[i] / 2 : present[i];
                // Profit is future price minus actual cost paid
                int profit = future[i] - cost;
                
                totalCost += cost;
                totalProfit += profit;
                
                if (totalCost > budget) {
                    valid = 0;
                    break;
                }
            }
        }
        
        if (valid && totalProfit > maxProfit) {
            maxProfit = totalProfit;
        }
    }
    
    return maxProfit;
}

// Simple parser for test input
void parseArray(char* str, int* arr, int n) {
    char* ptr = str + 1; // Skip [
    for (int i = 0; i < n; i++) {
        arr[i] = strtol(ptr, &ptr, 10);
        if (*ptr == ',') ptr++;
    }
}

void parseHierarchy(char* str, int hierarchy[][2], int* size) {
    *size = 0;
    if (strcmp(str, "[]") == 0) return;
    
    char* ptr = str + 1; // Skip [
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            hierarchy[*size][0] = strtol(ptr, &ptr, 10);
            if (*ptr == ',') ptr++;
            hierarchy[*size][1] = strtol(ptr, &ptr, 10);
            (*size)++;
        }
        ptr++;
    }
}

int main() {
    int n;
    scanf("%d", &n);
    
    int present[n], future[n];
    int hierarchy[n][2];
    int hierarchySize = 0;
    
    char line[1000];
    
    // Read present array
    scanf(" %[^\n]", line);
    parseArray(line, present, n);
    
    // Read future array
    scanf(" %[^\n]", line);
    parseArray(line, future, n);
    
    // Read hierarchy
    scanf(" %[^\n]", line);
    parseHierarchy(line, hierarchy, &hierarchySize);
    
    int budget;
    scanf("%d", &budget);
    
    int result = solution(n, present, future, hierarchy, hierarchySize, budget);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × 2^n)

Generate 2^n combinations, each taking O(n) time to process

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth and temporary arrays

⚡ Linearithmic Space

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

Maximum Profit from Trading Stocks with Discounts - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler