Maximum Profitable Triplets With Increasing Prices I

Maximum Profitable Triplets With Increasing Prices I - Problem

You're running an online store with n items, each having a specific price and potential profit. Your goal is to select exactly three items that will maximize your total profit, but there's a catch!

The three items you pick must satisfy a strict ordering condition: if you select items at indices i, j, and k, then:

i < j < k (indices must be in increasing order)
prices[i] < prices[j] < prices[k] (prices must also be strictly increasing)

If you successfully pick three items meeting these conditions, your total profit will be profits[i] + profits[j] + profits[k].

Your task: Return the maximum profit you can achieve by selecting three items, or -1 if no valid triplet exists.

Input & Output

example_1.py — Basic Case

$ Input: prices = [10, 20, 30], profits = [5, 10, 15]

› Output: 30

💡 Note: We can select all three items (indices 0, 1, 2) since prices are strictly increasing (10 < 20 < 30). Total profit = 5 + 10 + 15 = 30.

example_2.py — No Valid Triplet

$ Input: prices = [30, 20, 10], profits = [15, 10, 5]

› Output: -1

💡 Note: No valid triplet exists because prices are in decreasing order. We need strictly increasing prices to form a valid triplet.

example_3.py — Multiple Valid Triplets

$ Input: prices = [1, 3, 2, 4, 5], profits = [1, 5, 3, 6, 7]

› Output: 18

💡 Note: Best triplet is at indices (0, 3, 4): prices [1, 4, 5] with profits [1, 6, 7]. Total profit = 1 + 6 + 7 = 14. Actually, better is indices (1, 3, 4): prices [3, 4, 5] with profits [5, 6, 7] = 18.

Constraints

3 ≤ n ≤ 2000
1 ≤ prices[i] ≤ 5000
1 ≤ profits[i] ≤ 5000
prices[i] values may have duplicates
We need strictly increasing prices: prices[i] < prices[j] < prices[k]

Visualization

Tap to expand

Understanding the Visualization

Choose First Stock

Select a stock with lower price as the foundation

Choose Second Stock

Pick a middle-priced stock that costs more than the first

Choose Third Stock

Select the highest-priced stock to complete the ascending sequence

Calculate Returns

Sum up profits from all three stocks for total portfolio return

Key Takeaway

🎯 Key Insight: For each middle element, we only need to track the maximum profit from cheaper items on the left and more expensive items on the right, then combine them optimally.

Asked in

G Google 35 a Amazon 28 ⊞ Microsoft 22 f Meta 18

The optimal approach uses two-pass preprocessing to achieve O(n²) time complexity. For each middle element, we precompute the maximum profit available from valid left and right elements, then combine them. Advanced solutions can use segment trees or binary indexed trees to achieve O(n log n) complexity for the harder variant.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Triple Nested Loops)	O(n³)	O(1)	Check all possible triplets with three nested loops
Two-Pass Optimization	O(n²)	O(n)	Precompute left and right maximum profits for each middle element
Optimized with Binary Search	O(n² log n)	O(n)	Use binary search to efficiently find valid left and right elements for each middle choice

Brute Force (Triple Nested Loops) — Algorithm Steps

Use three nested loops: i from 0 to n-3, j from i+1 to n-2, k from j+1 to n-1
For each triplet (i,j,k), check if prices[i] < prices[j] < prices[k]
If valid, calculate profit = profits[i] + profits[j] + profits[k]
Keep track of maximum profit found
Return maximum profit or -1 if no valid triplet exists

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize loops

Start with i=0, j=1, k=2

Check price condition

Verify prices[i] < prices[j] < prices[k]

Calculate profit

If valid, sum profits[i] + profits[j] + profits[k]

Update maximum

Keep track of the highest profit found

Continue search

Move to next triplet combination

Code -

solution.c — C

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

int maxProfit(int* prices, int* profits, int n) {
    int maxProfit = -1;
    
    // Try all possible triplets
    for (int i = 0; i < n - 2; i++) {
        for (int j = i + 1; j < n - 1; j++) {
            for (int k = j + 1; k < n; k++) {
                // Check if prices are strictly increasing
                if (prices[i] < prices[j] && prices[j] < prices[k]) {
                    int currentProfit = profits[i] + profits[j] + profits[k];
                    if (currentProfit > maxProfit) {
                        maxProfit = currentProfit;
                    }
                }
            }
        }
    }
    
    return maxProfit;
}

int main() {
    int prices[] = {10, 20, 30};
    int profits[] = {5, 10, 15};
    int n = 3;
    printf("%d\n", maxProfit(prices, profits, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops, each potentially running n times

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track maximum profit

✓ Linear Space

28.4K Views

Medium-High Frequency

~25 min Avg. Time

856 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 (Triple Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler