Maximum Increasing Triplet Value

Maximum Increasing Triplet Value - Problem

Given an integer array nums, return the maximum value of a triplet (i, j, k) such that i < j < k and nums[i] < nums[j] < nums[k].

The value of a triplet (i, j, k) is defined as nums[i] - nums[j] + nums[k].

If no such triplet exists, return 0.

Input & Output

Example 1 — Basic Increasing Triplet

$ Input: nums = [2,1,3,4]

› Output: 3

💡 Note: The optimal triplet is at indices (0,2,3) with values (2,3,4). Since 2 < 3 < 4, the triplet value is 2 - 3 + 4 = 3.

Example 2 — Multiple Valid Triplets

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

› Output: 4

💡 Note: Multiple triplets exist. The best is (0,1,4) with values (1,2,5), giving 1 - 2 + 5 = 4. Any triplet (i,j,k) with i < j < k works since array is strictly increasing.

Example 3 — No Valid Triplet

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

› Output: 0

💡 Note: Array is decreasing, so no triplet (i,j,k) exists where nums[i] < nums[j] < nums[k]. Return 0.

Constraints

3 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁶

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15

The key insight is to maximize nums[i] + nums[k] while minimizing nums[j] in the triplet formula. The optimal approach uses a single pass to track running minimums and maximum triplet values. Time: O(n), Space: O(1)

Common Approaches

✓ Sort First

⏱️ Time: N/A Space: N/A

Brute Force - Three Nested Loops

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

Use three nested loops to examine every possible combination of indices i < j < k where nums[i] < nums[j] < nums[k]. Calculate the value nums[i] - nums[j] + nums[k] for each valid triplet and track the maximum.

Single Pass Optimization

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

Scan the array once, maintaining the minimum value seen so far and the maximum possible triplet value ending at current position. For each element, it can serve as either the first, middle, or last element of a triplet.

Two Pass Optimization

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

Make two passes through the array: first pass finds the minimum value to the left of each position, second pass finds the maximum value to the right. Then scan once more to find the optimal middle element that maximizes the triplet value.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

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

int max(int a, int b) {
    return a > b ? a : b;
}

int solution(int* nums, int numsSize) {
    qsort(nums, numsSize, sizeof(int), compare);
    // Product of two largest elements
    int product1 = nums[numsSize-1] * nums[numsSize-2];
    // Product of two smallest elements
    int product2 = nums[0] * nums[1];
    // Return maximum difference
    return max(product1 - product2, product2 - product1);
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int size = 0;
    char* token = strtok(line, "[,]");
    
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != '\n') {
            nums[size++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int result = solution(nums, size);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

23.4K Views

Medium Frequency

~25 min Avg. Time

847 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