Maximum Increasing Triplet Value

Maximum Increasing Triplet Value - Problem

You are given an integer array nums. Your task is to find three indices i, j, and k such that:

i < j < k (indices must be in increasing order)
nums[i] < nums[j] < nums[k] (values must form a strictly increasing sequence)
The value of the triplet is nums[i] - nums[j] + nums[k]

Return the maximum possible value among all valid triplets. If no such triplet exists, return 0.

Example: For array [1, 5, 3, 6], we can form triplet (0, 1, 3) where 1 < 5 < 6, giving us value 1 - 5 + 6 = 2.

Input & Output

example_1.py — Basic Case

$ Input: [1, 5, 3, 6]

› Output: 4

💡 Note: The valid increasing triplets are (0,1,3) with value 1-5+6=2 and (0,2,3) with value 1-3+6=4. The maximum is 4.

example_2.py — No Valid Triplet

$ Input: [5, 4, 3, 2, 1]

› Output: 0

💡 Note: The array is decreasing, so no increasing triplet exists.

example_3.py — Multiple Triplets

$ Input: [1, 3, 2, 4, 5]

› Output: 4

💡 Note: Valid triplets: (0,1,3): 1-3+4=2, (0,1,4): 1-3+5=3, (0,2,3): 1-2+4=3, (0,2,4): 1-2+5=4, (2,3,4): 2-4+5=3. Maximum is 4.

Constraints

3 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁶
All elements in nums are positive integers

Visualization

Tap to expand

Understanding the Visualization

Choose Transaction Point

Pick a middle point j where you'll pay the transaction fee (nums[j])

Find Best Buy Price

Look for the lowest buy price before j (minimum nums[i] where i < j and nums[i] < nums[j])

Find Best Sell Price

Look for the highest sell price after j (maximum nums[k] where k > j and nums[k] > nums[j])

Calculate Profit

Profit = buy_price - transaction_fee + sell_price = nums[i] - nums[j] + nums[k]

Key Takeaway

🎯 Key Insight: For maximum profit, fix the transaction fee point and find the optimal buy low/sell high boundaries around it.

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 25 f Meta 18

The optimal approach uses a two-pass strategy where we fix each middle element and efficiently find the best boundaries. For each potential middle element j, we find the minimum element before j that's smaller than nums[j], and the maximum element after j that's larger than nums[j]. This reduces time complexity from O(n³) to O(n²) while maintaining intuitive logic.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized with Binary Search	O(n²)	O(n)	For each middle element, use binary search to find optimal boundaries
Brute Force (Triple Nested Loops)	O(n³)	O(1)	Check all possible triplets with three nested loops

Optimized with Binary Search — Algorithm Steps

Preprocess: create arrays of minimum values from left and maximum values from right
For each middle index j, find the smallest nums[i] where i < j and nums[i] < nums[j]
Find the largest nums[k] where k > j and nums[k] > nums[j]
Use binary search on preprocessed data for efficient lookups
Calculate nums[i] - nums[j] + nums[k] and track maximum

Visualization

Tap to expand

Step-by-Step Walkthrough

Fix Middle

Choose middle element nums[j]

Search Left

Find minimum valid element before j

Search Right

Find maximum valid element after j

Calculate

Compute triplet value if valid triplet exists

Code -

solution.c — C

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

int maximumTripletValue(int* nums, int n) {
    if (n < 3) return 0;
    
    int maxValue = 0;
    
    for (int j = 1; j < n - 1; j++) {
        int minBefore = INT_MAX;
        int maxAfter = INT_MIN;
        
        // Find minimum element before j that is less than nums[j]
        for (int i = 0; i < j; i++) {
            if (nums[i] < nums[j] && nums[i] < minBefore) {
                minBefore = nums[i];
            }
        }
        
        // Find maximum element after j that is greater than nums[j]
        for (int k = j + 1; k < n; k++) {
            if (nums[k] > nums[j] && nums[k] > maxAfter) {
                maxAfter = nums[k];
            }
        }
        
        if (minBefore != INT_MAX && maxAfter != INT_MIN) {
            int value = minBefore - nums[j] + maxAfter;
            if (value > maxValue) {
                maxValue = value;
            }
        }
    }
    
    return maxValue;
}

int main() {
    int nums[1000];
    int n = 0;
    char c;
    while (scanf("%d%c", &nums[n], &c) && n++ < 999 && c != '\n');
    printf("%d\n", maximumTripletValue(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n) for each middle element, with O(n) preprocessing

⚠ Quadratic Growth

Space Complexity

O(n)

Additional arrays for preprocessing minimum and maximum values

⚡ Linearithmic Space

48.2K Views

Medium-High Frequency

~25 min Avg. Time

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