Maximum Profitable Triplets With Increasing Prices II

Maximum Profitable Triplets With Increasing Prices II - Problem

You are given two 0-indexed arrays prices and profits of length n. There are n items in a store where the i^th item has a price of prices[i] and a profit of profits[i].

We need to pick exactly three items with the following condition: prices[i] < prices[j] < prices[k] where i < j < k.

If we pick items with indices i, j, and k satisfying the above condition, the profit would be profits[i] + profits[j] + profits[k].

Return the maximum profit we can get, or -1 if it's not possible to pick three items with the given condition.

Input & Output

Example 1 — Basic Valid Triplet

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

› Output: 120

💡 Note: Pick indices (0,1,2): prices 10 < 20 < 30, profits 20+30+40 = 90. Pick indices (0,1,3): prices 10 < 20 < 40, profits 20+30+50 = 100. Pick indices (0,2,3): prices 10 < 30 < 40, profits 20+40+50 = 110. Pick indices (1,2,3): prices 20 < 30 < 40, profits 30+40+50 = 120. Maximum is 120.

Example 2 — No Valid Triplet

$ Input: prices = [4,3,2,1], profits = [33,20,19,56]

› Output: -1

💡 Note: Prices are in decreasing order, so no triplet (i,j,k) exists where prices[i] < prices[j] < prices[k].

Example 3 — Mixed Order

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

› Output: 21

💡 Note: Pick indices (0,1,3): prices 1 < 7 < 10, profits 5+10+6 = 21. Pick indices (0,2,3): prices 1 < 3 < 10, profits 5+3+6 = 14. Best valid triplet gives profit 21.

Constraints

3 ≤ prices.length = profits.length ≤ 2000
1 ≤ prices[i] ≤ 5000
1 ≤ profits[i] ≤ 10⁶

Visualization

Tap to expand

Asked in

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

The key insight is to fix the middle element and efficiently find maximum profits on left and right with valid price constraints. The optimal approach uses advanced data structures like segment trees for O(n log n) complexity, but the simpler O(n²) fix-middle solution works well for most cases. Time: O(n²), Space: O(1).

Common Approaches

✓ Brute Force - Check All Triplets

⏱️ Time: O(n³) Space: O(1)

Generate all possible combinations of three indices where i < j < k, verify the price constraint, and track maximum profit sum.

Fix Middle Element

⏱️ Time: O(n²) Space: O(1)

Fix the middle index j, then scan left to find the maximum profit where price < prices[j], and scan right to find maximum profit where price > prices[j].

Segment Tree / Binary Indexed Tree

⏱️ Time: O(n log n) Space: O(n)

Sort items by price, then use segment tree or BIT to efficiently find maximum profit in left and right ranges for each middle element.

Brute Force - Check All Triplets — Algorithm Steps

Use three nested loops for indices i, j, k
Check if prices[i] < prices[j] < prices[k]
Calculate profit sum and update maximum

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Triplets

Use three nested loops to generate all (i,j,k) where i < j < k

Check Constraints

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

Track Maximum

Calculate profit sum and update maximum

Code -

solution.c — C

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

int solution(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 currentProfit = profits[i] + profits[j] + profits[k];
                    if (maxProfit == -1 || currentProfit > maxProfit) {
                        maxProfit = currentProfit;
                    }
                }
            }
        }
    }
    
    return maxProfit;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int prices[1000], profits[1000];
    int n = 0;
    
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        prices[n++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    fgets(line, sizeof(line), stdin);
    int m = 0;
    token = strtok(line + 1, ",]");
    while (token != NULL) {
        profits[m++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int result = solution(prices, profits, n);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops iterate through all possible triplet combinations

⚡ Linearithmic

Space Complexity

O(1)

Only using a few variables to track maximum profit

⚡ Linearithmic Space

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Check All Triplets — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler