Codestin Search App

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.

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.

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops, each running up to n iterations

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track maximum profit

✓ Linear Space

Constraints

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

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
✓ Brute Force (Triple Nested Loops)	O(n³)	O(1)	Check all possible triplets with three nested loops
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) — Algorithm Steps

Use three nested loops for indices i, j, k where i < j < k
For each triplet, verify prices[i] < prices[j] < prices[k]
If valid, calculate profit sum and update maximum
Return maximum profit found, or -1 if no valid triplet exists

Visualization

Tap to expand

Step-by-Step Walkthrough

Outer Loop (i)

Start with first element as the smallest price

Middle Loop (j)

Find middle elements with price > prices[i]

Inner Loop (k)

Find largest elements with price > prices[j]

Validation

Check if triplet satisfies price constraint and update max profit

Code -

solution.c — C

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

int maxProfitTriplets(int* prices, int* profits, int n) {
    int maxProfit = -1;
    
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            for (int k = j + 1; k < n; k++) {
                if (prices[i] < prices[j] && prices[j] < prices[k]) {
                    int profit = profits[i] + profits[j] + profits[k];
                    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³)

Three nested loops, each running up to n iterations

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track maximum profit

✓ Linear Space

Constraints

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

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Triple Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler