Count Increasing Quadruplets

Count Increasing Quadruplets - Problem

Given a 0-indexed integer array nums of size n containing all numbers from 1 to n, return the number of increasing quadruplets.

A quadruplet (i, j, k, l) is increasing if:

0 <= i < j < k < l < n, and
nums[i] < nums[k] < nums[j] < nums[l]

Notice the specific ordering pattern: element at position k comes between elements at positions i and j in value, creating a unique increasing subsequence pattern.

Input & Output

Example 1 — Basic Case

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

› Output: 2

💡 Note: Two valid quadruplets: (0,1,2,3) where 1<2<3<4, and (0,1,2,4) where 1<2<3<5. Both follow the pattern nums[i]

Example 2 — No Valid Quadruplets

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

› Output: 0

💡 Note: Array is decreasing, so no quadruplet can satisfy the increasing condition nums[i] < nums[k] < nums[j] < nums[l].

Example 3 — Complex Pattern

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

› Output: 3

💡 Note: Valid quadruplets: (1,2,3,4) gives 1<2<5<6, (1,2,5,4) gives 1<3<5<6, and (1,4,5,2) gives 1<3<6

Constraints

4 ≤ nums.length ≤ 4000
1 ≤ nums[i] ≤ nums.length
All values in nums are unique
nums contains all integers from 1 to n

Visualization

Tap to expand

Asked in

G Google 15 F Facebook 12 a Amazon 8

The key insight is recognizing the unique crossing pattern where nums[i] < nums[k] < nums[j] < nums[l] with i

Common Approaches

✓ Dfs

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

Brute Force - Check All Quadruplets

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

Generate all possible quadruplets (i,j,k,l) with i<j<k<l and check if nums[i] < nums[k] < nums[j] < nums[l]. This directly implements the problem definition but is inefficient for large inputs.

Dynamic Programming with Precomputation

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

Use 2D arrays to precompute: left[j][k] = count of i < j where nums[i] < nums[k], and right[j][k] = count of l > k where nums[j] < nums[l]. This eliminates redundant counting in the inner loops.

Fix Middle Elements (j,k)

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

For each pair (j,k) where j < k, count how many i < j satisfy nums[i] < nums[k], and how many l > k satisfy nums[j] < nums[l]. The product gives valid quadruplets for this (j,k) pair.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

struct TreeNode {
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
};

struct TreeNode* createNode(int val) {
    struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

struct DFSResult {
    int subtreeSum;
    int count;
};

struct DFSResult dfs(struct TreeNode* node) {
    struct DFSResult result = {0, 0};
    if (!node) return result;
    
    // Get subtree sums and counts from children
    struct DFSResult leftResult = dfs(node->left);
    struct DFSResult rightResult = dfs(node->right);
    
    // Total descendant sum for current node
    int descendantSum = leftResult.subtreeSum + rightResult.subtreeSum;
    
    // Count matches in current subtree
    result.count = leftResult.count + rightResult.count;
    
    // Check if current node value equals descendant sum
    if (node->val == descendantSum) {
        result.count++;
    }
    
    // Return total sum of subtree rooted at current node
    result.subtreeSum = node->val + descendantSum;
    
    return result;
}

int solution(struct TreeNode* root) {
    if (!root) return 0;
    struct DFSResult result = dfs(root);
    return result.count;
}

struct TreeNode* buildTree(char* input) {
    if (!input || strlen(input) < 3) return NULL;
    
    // Remove brackets and parse
    char* str = input + 1; // skip '['
    str[strlen(str)-1] = '\0'; // remove ']'
    
    if (strlen(str) == 0) return NULL;
    
    // Parse first number
    char* token = strtok(str, ",");
    if (!token) return NULL;
    
    int val = atoi(token);
    struct TreeNode* root = createNode(val);
    
    struct TreeNode* queue[100000];
    int front = 0, rear = 0;
    queue[rear++] = root;
    
    while (front < rear) {
        struct TreeNode* node = queue[front++];
        
        // Left child
        token = strtok(NULL, ",");
        if (token && strcmp(token, "null") != 0) {
            int leftVal = atoi(token);
            node->left = createNode(leftVal);
            queue[rear++] = node->left;
        }
        
        // Right child
        token = strtok(NULL, ",");
        if (token && strcmp(token, "null") != 0) {
            int rightVal = atoi(token);
            node->right = createNode(rightVal);
            queue[rear++] = node->right;
        }
    }
    
    return root;
}

int main() {
    char input[100000];
    fgets(input, sizeof(input), stdin);
    
    // Remove newline
    input[strcspn(input, "\n")] = '\0';
    
    struct TreeNode* root = buildTree(input);
    int result = solution(root);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

✓ Linear Space

35.6K Views

Medium Frequency

~35 min Avg. Time

890 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

Algorithm Visualization

Pinch to zoom • Tap outside to close

Test Cases

0 passed

0 failed

3 pending

Select Compiler

Choose a programming language

Compiler list would appear here...