Maximum Profitable Triplets With Increasing Prices II

Maximum Profitable Triplets With Increasing Prices II - Problem

You're running an online marketplace and need to maximize profit by selecting three items with strictly increasing prices. Given two arrays:

prices[i] - the price of the ith item
profits[i] - the profit from selling the ith item

Find three items at indices i < j < k where prices[i] < prices[j] < prices[k] and maximize profits[i] + profits[j] + profits[k].

Goal: Return the maximum possible profit from such a triplet, or -1 if no valid triplet exists.

Example: If prices = [10, 20, 30, 40] and profits = [20, 30, 40, 50], the answer is 120 (selecting all items gives maximum profit).

Input & Output

example_1.py — Basic Valid Triplet

$ Input: prices = [10, 20, 30, 40]\nprofits = [20, 30, 40, 50]

› Output: 120

💡 Note: We can select all items: indices (0,1,2) give profit 20+30+40=90, indices (0,1,3) give 20+30+50=100, indices (0,2,3) give 20+40+50=110, indices (1,2,3) give 30+40+50=120. The maximum is 120.

example_2.py — No Valid Triplet

$ Input: prices = [40, 30, 20, 10]\nprofits = [50, 40, 30, 20]

› Output: -1

💡 Note: Prices are in decreasing order, so no triplet with increasing prices exists.

example_3.py — Mixed Case

$ Input: prices = [5, 10, 15, 8, 12]\nprofits = [100, 20, 30, 40, 50]

› Output: 190

💡 Note: Best triplet is indices (0,3,4) with prices [5,8,12] and profits 100+40+50=190.

Constraints

3 ≤ n ≤ 10⁵
1 ≤ prices[i] ≤ 10⁶
1 ≤ profits[i] ≤ 10⁶
prices[i] and profits[i] can be independent values

Visualization

Tap to expand

Understanding the Visualization

Scan Portfolio

Look through all available stocks in chronological order

Track Price Ranges

For each stock, know the best profits available from cheaper and more expensive stocks

Optimal Selection

Pick the combination that gives maximum total profit while maintaining price order

Efficient Lookup

Use advanced data structures to avoid checking every combination manually

Key Takeaway

🎯 Key Insight: Use Binary Indexed Tree to efficiently query maximum profits in price ranges, avoiding the need to check all possible triplet combinations manually.

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal approach uses Binary Indexed Tree (BIT) with coordinate compression to achieve O(n log n) time complexity. For each element as the middle of a triplet, we efficiently query the maximum profit from elements with smaller prices (left) and larger prices (right) using precomputed data structures.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Indexed Tree (Optimal)	O(n log n)	O(n)	Use Binary Indexed Tree to efficiently query maximum profits for price ranges
Brute Force (Triple Nested Loops)	O(n³)	O(1)	Check all possible triplets with three nested loops

Binary Indexed Tree (Optimal) — Algorithm Steps

Compress coordinates by sorting unique prices and mapping to indices
Build suffix array to store maximum profit for prices >= each price
For each element as middle, use BIT to query maximum profit from left with smaller prices
Combine left max + current profit + right max for price ranges
Update BIT with current element and continue

Visualization

Tap to expand

Step-by-Step Walkthrough

Coordinate Compression

Map prices to indices for BIT operations

Suffix Array

Precompute maximum profits for all prices >= each value

BIT Queries

For each middle element, query left max efficiently

Update & Combine

Update BIT and combine left + middle + right profits

Code -

solution.c — C

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

typedef struct {
    int n;
    int* tree;
} BIT;

BIT* createBIT(int n) {
    BIT* bit = (BIT*)malloc(sizeof(BIT));
    bit->n = n;
    bit->tree = (int*)calloc(n + 1, sizeof(int));
    return bit;
}

void updateBIT(BIT* bit, int i, int val) {
    i += 1;
    while (i <= bit->n) {
        if (bit->tree[i] < val) {
            bit->tree[i] = val;
        }
        i += i & (-i);
    }
}

int queryBIT(BIT* bit, int i) {
    i += 1;
    int res = 0;
    while (i > 0) {
        if (bit->tree[i] > res) {
            res = bit->tree[i];
        }
        i -= i & (-i);
    }
    return res;
}

int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

int maxProfitTriplets(int* prices, int* profits, int n) {
    if (n < 3) return -1;
    
    // Simple O(n^2) approach for C implementation
    int maxProfit = -1;
    
    for (int j = 1; j < n - 1; j++) {
        int leftMax = 0, rightMax = 0;
        
        // Find maximum profit from left with smaller price
        for (int i = 0; i < j; i++) {
            if (prices[i] < prices[j] && profits[i] > leftMax) {
                leftMax = profits[i];
            }
        }
        
        // Find maximum profit from right with larger price
        for (int k = j + 1; k < n; k++) {
            if (prices[k] > prices[j] && profits[k] > rightMax) {
                rightMax = profits[k];
            }
        }
        
        if (leftMax > 0 && rightMax > 0) {
            int profit = leftMax + profits[j] + rightMax;
            if (profit > maxProfit) {
                maxProfit = profit;
            }
        }
    }
    
    return maxProfit;
}

int main() {
    int prices[1000], profits[1000];
    int n = 0;
    char c;
    
    // Read prices
    while (scanf("%d%c", &prices[n], &c)) {
        n++;
        if (c == '\n') break;
    }
    
    // Read profits
    for (int i = 0; i < n; i++) {
        scanf("%d", &profits[i]);
    }
    
    printf("%d\n", maxProfitTriplets(prices, profits, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting for coordinate compression O(n log n) + BIT operations O(n log n)

⚡ Linearithmic

Space Complexity

O(n)

BIT structure and coordinate compression arrays

⚡ Linearithmic Space

38.0K Views

High Frequency

~25 min Avg. Time

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

Binary Indexed Tree (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler