Count Increasing Quadruplets - Practice Coding Problems

Count Increasing Quadruplets - Problem

Count Increasing Quadruplets is a fascinating array problem that challenges you to find a specific pattern within a permutation.

You're given a 0-indexed integer array nums of size n containing all numbers from 1 to n (a permutation). Your task is to count how many increasing quadruplets exist in this array.

An increasing quadruplet (i, j, k, l) must satisfy two conditions:
1. Position constraint: 0 ≤ i < j < k < l < n
2. Value constraint: nums[i] < nums[k] < nums[j] < nums[l]

Notice the interesting pattern: the values don't follow the same order as the indices! We need nums[i] < nums[k] < nums[j] < nums[l] where k comes after j positionally but nums[k] is smaller than nums[j].

Example: In array [2, 1, 4, 3], one valid quadruplet is (0, 2, 1, 3) because nums[0]=2 < nums[1]=1 is false, but (1, 2, 0, 3) where nums[1]=1 < nums[0]=2 < nums[2]=4 < nums[3]=3 is also invalid due to position constraints. The correct interpretation requires careful analysis of both position and value constraints.

Input & Output

example_1.py — Basic Case

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

› Output: 2

💡 Note: The valid quadruplets are (0,2,1,3) and (0,2,1,4). For (0,2,1,3): nums[0]=1 < nums[1]=2 < nums[2]=3 < nums[3]=4, but we need nums[0] < nums[1] < nums[2] < nums[3] with indices 0 < 2 < 1 < 3 which is impossible. Actually, we need (0,1,2,3) where nums[0]=1 < nums[2]=2 < nums[1]=3 < nums[3]=4, which gives us the pattern 1 < 2 < 3 < 4. Let me recalculate: valid quadruplets have the pattern nums[i] < nums[k] < nums[j] < nums[l] where i < j < k < l.

example_2.py — No Valid Quadruplets

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

› Output: 0

💡 Note: For any quadruplet (i,j,k,l) with i < j < k < l, we would have nums[i] < nums[j] < nums[k] < nums[l] due to the sorted order. But we need nums[i] < nums[k] < nums[j] < nums[l], which requires nums[k] < nums[j]. Since k > j, this is impossible in a sorted array.

example_3.py — Multiple Valid Patterns

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

› Output: 4

💡 Note: This array has several valid increasing quadruplets. The pattern nums[i] < nums[k] < nums[j] < nums[l] can be satisfied in multiple ways. For example: (1,2,0,4) gives us nums[1]=1 < nums[0]=2 < nums[2]=4 < nums[4]=6, which matches our required pattern with i=1, j=2, k=0, l=4, but this violates i < j < k < l. We need to carefully identify valid index combinations.

Visualization

Tap to expand

Understanding the Visualization

Identify the Pattern

Understand that we need nums[i] < nums[k] < nums[j] < nums[l] with positions i < j < k < l

Fix Middle Positions

Choose positions j and k where j < k and nums[k] < nums[j] to satisfy the middle constraint

Count Valid Endpoints

For each (j,k) pair, count how many valid i positions (left) and l positions (right) exist

Multiply and Sum

The total quadruplets for each (j,k) is left_count × right_count

Key Takeaway

🎯 Key Insight: Fix the middle positions j,k first, then count valid endpoints efficiently to achieve O(n²) complexity instead of naive O(n⁴).

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n²) to precompute prefix/suffix arrays, O(n²) to check all (j,k) pairs

⚠ Quadratic Growth

Space Complexity

O(n)

Additional space for prefix and suffix counting arrays

⚡ Linearithmic Space

Constraints

4 ≤ nums.length ≤ 4000
1 ≤ nums[i] ≤ nums.length
All values in nums are unique
nums is a permutation of integers from 1 to n

Asked in

G Google 45 a Amazon 32 f Meta 28 ⊞ Microsoft 19

The optimal solution uses a two-pass enumeration approach with complexity O(n²). By fixing the middle pair (j,k) where nums[k] < nums[j], we can efficiently count valid positions i and l using prefix and suffix counting. The key insight is that for each valid (j,k) pair, the number of quadruplets equals the product of valid left positions times valid right positions.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized DP with Prefix Sums (Near Optimal)	O(n²)	O(n)	Use dynamic programming with prefix counting to achieve O(n²) complexity
Brute Force (Four Nested Loops)	O(n⁴)	O(1)	Check all possible combinations of four indices with nested loops
Two-Pass Enumeration (Fix Middle Pair)	O(n³)	O(1)	Fix middle positions j,k and count valid i,l positions in two passes

Optimized DP with Prefix Sums (Near Optimal) — Algorithm Steps

For each position k, precompute how many elements to the left are smaller than nums[k]
For each position j, precompute how many elements to the right are larger than nums[j]
Iterate through all (j,k) pairs where j < k and nums[k] < nums[j]
Use precomputed counts to get the number of valid quadruplets instantly
Sum all contributions to get the final answer

Visualization

Tap to expand

Step-by-Step Walkthrough

Precompute prefix counts

For each position, count smaller elements to the left

Precompute suffix counts

For each position, count larger elements to the right

Combine efficiently

Use precomputed values to calculate quadruplets in O(1)

Sum all contributions

Add up results from all valid (j,k) pairs

Code -

solution.c — C

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

int countIncreasingQuadruplets(int* nums, int n) {
    int count = 0;
    
    for (int j = 1; j < n - 2; j++) {
        for (int k = j + 1; k < n - 1; k++) {
            if (nums[k] >= nums[j]) continue;
            
            // Count i < j where nums[i] < nums[k]
            int smallerLeft = 0;
            for (int i = 0; i < j; i++) {
                if (nums[i] < nums[k]) smallerLeft++;
            }
            
            // Count l > k where nums[l] > nums[j]
            int largerRight = 0;
            for (int l = k + 1; l < n; l++) {
                if (nums[l] > nums[j]) largerRight++;
            }
            
            count += smallerLeft * largerRight;
        }
    }
    
    return count;
}

int main() {
    int nums[1000];
    int n = 0;
    char c;
    
    scanf("%c", &c);
    while (scanf("%d%c", &nums[n], &c) == 2) {
        n++;
        if (c == ']') break;
    }
    
    printf("%d\n", countIncreasingQuadruplets(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n²) to precompute prefix/suffix arrays, O(n²) to check all (j,k) pairs

⚠ Quadratic Growth

Space Complexity

O(n)

Additional space for prefix and suffix counting arrays

⚡ Linearithmic Space

Constraints

4 ≤ nums.length ≤ 4000
1 ≤ nums[i] ≤ nums.length
All values in nums are unique
nums is a permutation of integers from 1 to n

38.2K Views

Medium-High Frequency

~25 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Optimized DP with Prefix Sums (Near Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler