Count Special Subsequences

Count Special Subsequences - Problem

You are given an array nums consisting of positive integers. A special subsequence is defined as a subsequence of length 4, represented by indices (p, q, r, s), where p < q < r < s.

This subsequence must satisfy the following conditions:

nums[p] * nums[r] == nums[q] * nums[s]
There must be at least one element between each pair of indices. In other words, q - p > 1, r - q > 1 and s - r > 1.

Return the number of different special subsequences in nums.

Input & Output

Example 1 — Basic Case

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

› Output: 0

💡 Note: Array length is 4. For valid subsequence (p,q,r,s) with gaps q-p>1, r-q>1, s-r>1, we need at least 7 elements. No valid subsequence possible.

Example 2 — With Gaps

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

› Output: 2

💡 Note: Valid subsequences: (0,2,4,6) where 1×5=2×3=5 is false, but (0,2,4,7) where 1×5≠2×8. Actually checking: (0,2,5,7) gives 1×6=2×8=6 which is false. After checking all combinations, found 2 valid subsequences.

Example 3 — Multiple Solutions

$ Input: nums = [2,4,6,8,3,6,9,12]

› Output: 0

💡 Note: After checking all valid (p,q,r,s) combinations with proper gaps, no subsequence satisfies nums[p]×nums[r] = nums[q]×nums[s]

Constraints

7 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 1000

Visualization

Tap to expand

Asked in

G Google 15 f Meta 12 Apple 8

The key insight is recognizing that nums[p]×nums[r] = nums[q]×nums[s] is equivalent to nums[p]/nums[q] = nums[r]/nums[s]. Best approach uses hash map to store ratios for O(n³) time. Space: O(n²)

Common Approaches

✓ Brute Force - Check All Valid Combinations

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

Iterate through all possible combinations of 4 indices (p, q, r, s) with the constraints p < q < r < s, q-p > 1, r-q > 1, s-r > 1, and check if nums[p] * nums[r] == nums[q] * nums[s].

Hash Map Optimization

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

Instead of checking all combinations, we can optimize by storing pairs and their ratios in a hash map. For each pair of middle indices (q,r), we look for matching pairs with the same ratio.

Optimized Enumeration

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

Optimize the brute force by fixing two middle elements and efficiently counting valid pairs on both sides. This reduces the search space and eliminates some redundant calculations.

Brute Force - Check All Valid Combinations — Algorithm Steps

Generate all valid 4-tuples with proper spacing
Check multiplication condition for each tuple
Count valid subsequences

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Valid Indices

Find all (p,q,r,s) with gaps > 1

Check Condition

Test if nums[p]*nums[r] = nums[q]*nums[s]

Count Matches

Increment counter for valid subsequences

Code -

solution.c — C

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

int solution(int* nums, int n) {
    int count = 0;
    
    for (int p = 0; p < n; p++) {
        for (int q = p + 2; q < n; q++) {  // q - p > 1
            for (int r = q + 2; r < n; r++) {  // r - q > 1
                for (int s = r + 2; s < n; s++) {  // s - r > 1
                    if ((long long)nums[p] * nums[r] == (long long)nums[q] * nums[s]) {
                        count++;
                    }
                }
            }
        }
    }
    
    return count;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n⁴)

Four nested loops to check all possible 4-tuples

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

⚠ Quadratic Space

8.5K Views

Medium Frequency

~35 min Avg. Time

245 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 - Check All Valid Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler