Increasing Triplet Subsequence

Increasing Triplet Subsequence - Problem

Array Greedy Medium

Given an integer array nums, return true if there exists a triple of indices (i, j, k) such that i < j < k and nums[i] < nums[j] < nums[k].

If no such indices exist, return false.

Follow up: Can you implement a solution that runs in O(n) time complexity and O(1) space complexity?

Input & Output

Example 1 — Increasing Sequence

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

› Output: true

💡 Note: Any triplet (i,j,k) with i < j < k satisfies the condition. For instance, (0,1,2) gives us 1 < 2 < 3.

Example 2 — No Valid Triplet

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

› Output: false

💡 Note: No triplet satisfies the condition since the array is decreasing.

Example 3 — Mixed Values

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

› Output: true

💡 Note: The triplet (1,4,5) gives indices with values 1 < 4 < 6.

Constraints

1 ≤ nums.length ≤ 5 × 10⁵
-2³¹ ≤ nums[i] ≤ 2³¹ - 1

Visualization

Tap to expand

Asked in

f Facebook 42 G Google 38 a Amazon 31 M Microsoft 25

The key insight is to use a greedy approach tracking only two variables: the smallest value seen so far and the second smallest. When we find any value larger than both, we immediately know an increasing triplet exists. Best approach is the greedy two-variable method with Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force

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

Use three nested loops to check every combination of three indices (i, j, k) where i < j < k and verify if nums[i] < nums[j] < nums[k]. Return true as soon as we find such a triplet.

Greedy Two Variables

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

Use two variables to keep track of the smallest and second smallest values seen so far. When we find a value larger than both, we have found an increasing triplet. This works because we only care about the existence of such a triplet, not the actual indices.

Brute Force — Algorithm Steps

Iterate through all possible i positions
For each i, iterate through all j positions where j > i
For each (i,j) pair, iterate through all k positions where k > j
Check if nums[i] < nums[j] < nums[k], return true if found

Visualization

Tap to expand

Step-by-Step Walkthrough

Triple Nested Loops

Check all (i,j,k) where i < j < k

Compare Values

Test if nums[i] < nums[j] < nums[k]

Return Result

Return true when first valid triplet found

Code -

solution.c — C

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

bool solution(int* nums, int numsSize) {
    for (int i = 0; i < numsSize - 2; i++) {
        for (int j = i + 1; j < numsSize - 1; j++) {
            for (int k = j + 1; k < numsSize; k++) {
                if (nums[i] < nums[j] && nums[j] < nums[k]) {
                    return true;
                }
            }
        }
    }
    return false;
}

int main() {
    char line[100000];
    fgets(line, sizeof(line), stdin);
    
    int nums[500000];
    int numsSize = 0;
    
    char* ptr = strchr(line, '[');
    if (ptr) {
        ptr++;
        char* token = strtok(ptr, ",]");
        while (token != NULL) {
            nums[numsSize++] = atoi(token);
            token = strtok(NULL, ",]");
        }
    }
    
    bool result = solution(nums, numsSize);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops each running up to n iterations

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra variables

✓ Linear Space

205.4K Views

High Frequency

~15 min Avg. Time

6.4K 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 — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler