Subsequences with a Unique Middle Mode I

Subsequences with a Unique Middle Mode I - Problem

Given an integer array nums, find the number of subsequences of size 5 of nums with a unique middle mode.

Since the answer may be very large, return it modulo 10^9 + 7.

A mode of a sequence of numbers is defined as the element that appears the maximum number of times in the sequence.

A sequence of numbers contains a unique mode if it has only one mode.

A sequence of numbers seq of size 5 contains a unique middle mode if the middle element (seq[2]) is a unique mode.

Input & Output

Example 1 — Basic Case

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

› Output: 0

💡 Note: The only subsequence is [1,2,2,3,3]. Frequencies are 1:1, 2:2, 3:2. Maximum frequency is 2, but both 2 and 3 have this frequency, so there's no unique mode. The middle element 2 is not a unique mode.

Example 2 — Small Array

$ Input: nums = [1,1,1,1,1]

› Output: 1

💡 Note: Only one subsequence [1,1,1,1,1]. Middle element is 1 with frequency 5, which is the maximum and unique mode.

Example 3 — No Valid Subsequence

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

› Output: 1

💡 Note: The only subsequence is [1,2,3,4,5]. All elements have frequency 1. The middle element 3 has maximum frequency (1) and is the unique mode since when all elements have the same frequency, any element can be considered the unique mode in the context of this problem.

Constraints

5 ≤ nums.length ≤ 1000
-10⁹ ≤ nums[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 15 M Meta 12

The key insight is to fix each element as the middle element and count valid subsequences using combinatorics rather than generating all subsequences. The optimized approach reduces time complexity from O(n⁵) to O(n³). Time: O(n³), Space: O(n)

Common Approaches

✓ Brute Force - Generate All Subsequences

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

Generate every possible subsequence of size 5, then for each subsequence check if the middle element is the unique mode. This involves checking all combinations and validating the mode condition.

Optimized - Fix Middle Element

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

Instead of generating all subsequences, fix each element as the middle element and count how many valid subsequences can be formed. Use frequency counting and combinatorics to efficiently calculate the result.

Brute Force - Generate All Subsequences — Algorithm Steps

Generate all C(n,5) subsequences of size 5
For each subsequence, count frequency of each element
Check if middle element has highest frequency and is unique

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All

Create all possible subsequences of size 5

Check Mode

For each subsequence, verify if middle element is unique mode

Count Valid

Count subsequences where middle element is the unique mode

Code -

solution.c — C

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

int solution(int* nums, int n) {
    const int MOD = 1000000007;
    long long count = 0;
    
    // Generate all subsequences of size 5
    for (int i = 0; i < n; i++) {
        for (int j = i+1; j < n; j++) {
            for (int k = j+1; k < n; k++) {
                for (int l = k+1; l < n; l++) {
                    for (int m = l+1; m < n; m++) {
                        int subseq[5] = {nums[i], nums[j], nums[k], nums[l], nums[m]};
                        int middle = subseq[2]; // k-th element is middle
                        
                        // Count frequencies (simple approach for small array)
                        int freq[5] = {1, 0, 0, 0, 0};
                        int unique[5] = {subseq[0]};
                        int unique_count = 1;
                        
                        for (int x = 1; x < 5; x++) {
                            int found = -1;
                            for (int y = 0; y < unique_count; y++) {
                                if (unique[y] == subseq[x]) {
                                    found = y;
                                    break;
                                }
                            }
                            if (found != -1) {
                                freq[found]++;
                            } else {
                                unique[unique_count] = subseq[x];
                                freq[unique_count] = 1;
                                unique_count++;
                            }
                        }
                        
                        // Find max frequency
                        int maxFreq = 0;
                        for (int x = 0; x < unique_count; x++) {
                            if (freq[x] > maxFreq) maxFreq = freq[x];
                        }
                        
                        // Check if middle element has max frequency and is unique
                        int middle_freq = 0;
                        for (int x = 0; x < unique_count; x++) {
                            if (unique[x] == middle) {
                                middle_freq = freq[x];
                                break;
                            }
                        }
                        
                        if (middle_freq == maxFreq) {
                            int maxCount = 0;
                            for (int x = 0; x < unique_count; x++) {
                                if (freq[x] == maxFreq) maxCount++;
                            }
                            if (maxCount == 1) {
                                count = (count + 1) % MOD;
                            }
                        }
                    }
                }
            }
        }
    }
    
    return count;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array manually
    int nums[1000];
    int n = 0;
    char* ptr = line + 1; // Skip [
    char* token = strtok(ptr, ",]");
    while (token != NULL) {
        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⁵)

Need to check C(n,5) combinations, each taking O(1) to validate

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for counting frequencies

⚡ Linearithmic Space

8.5K Views

Medium Frequency

~25 min Avg. Time

280 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 - Generate All Subsequences — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler