Subsequences with a Unique Middle Mode II

Subsequences with a Unique Middle Mode II - Problem

Given an integer array nums, find the number of subsequences of size 5 where the middle element (3rd element) is the unique mode of the subsequence.

A mode is the element that appears most frequently in a sequence. A sequence has a unique mode if exactly one element appears with the highest frequency.

For a subsequence of size 5: [a, b, c, d, e], element c (the middle element) must be the unique mode. This means c appears more frequently than any other element in the subsequence.

Example: In subsequence [1, 2, 3, 3, 4], element 3 appears twice while others appear once, so 3 is the unique mode.

Since the answer can be very large, return it modulo 10⁹ + 7.

Input & Output

example_1.py — Basic Case

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

› Output: 3

💡 Note: Valid subsequences: [1,2,3,3,4] (middle=3, appears 2 times, others appear 1 time), and two other arrangements where 3 is the unique mode in middle position.

example_2.py — No Valid Subsequences

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

› Output: 0

💡 Note: All elements are distinct, so no element can be a mode (appear more than once). No valid subsequences exist.

example_3.py — Multiple Same Elements

$ Input: [1, 1, 1, 1, 1]

› Output: 1

💡 Note: Only one subsequence [1,1,1,1,1] where middle element 1 is the unique mode (appears 5 times, no other elements exist).

Constraints

5 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 1000
Return answer modulo 10⁹ + 7

Visualization

Tap to expand

Understanding the Visualization

Choose Committee Chair

The middle person becomes the committee chair - their party must have the most members

Count Party Members

Count how many members of chair's party are available on left and right sides

Calculate Combinations

Use math to count ways to form committee without chair's party being tied with others

Verify Majority

Ensure chair's party has strictly more members than any other party in the committee

Key Takeaway

🎯 Key Insight: By fixing the middle element and using combinatorial formulas, we avoid the exponential explosion of generating all possible subsequences, reducing complexity from O(n⁵) to O(n²).

Asked in

G Google 25 f Meta 18 ⊞ Microsoft 15 a Amazon 12

The optimal approach uses combinatorial mathematics instead of generating all subsequences. For each position as middle element, count frequencies in left/right subarrays and use C(n,r) formulas to calculate valid arrangements. This reduces complexity from O(n⁵) to O(n²), making it practical for large inputs while ensuring the middle element is the unique mode.

Common Approaches

Approach	Time	Space	Notes
✓ Combinatorial Count (Optimal)	O(n²)	O(n)	Fix middle element and use combinatorics to count valid arrangements
Brute Force (Generate All Subsequences)	O(n^5)	O(1)	Generate all possible subsequences of size 5 and check each one

Combinatorial Count (Optimal) — Algorithm Steps

For each position i as potential middle element
Count occurrences of nums[i] in left and right subarrays
Count different elements in left and right subarrays
Use combinatorics to calculate valid arrangements
Sum up all valid combinations

Visualization

Tap to expand

Step-by-Step Walkthrough

Fix Middle Element

Choose position i as the middle element of subsequence

Count Left/Right

Count occurrences of middle value in left and right subarrays

Calculate Combinations

Use C(n,r) formula to count ways to pick remaining elements

Verify Unique Mode

Ensure middle element frequency is strictly greater than others

Code -

solution.c — C

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

#define MOD 1000000007
#define MAXN 1005

long long modPow(long long base, long long exp, long long mod) {
    long long result = 1;
    base = base % mod;
    while (exp > 0) {
        if (exp % 2 == 1) {
            result = (result * base) % mod;
        }
        exp = exp / 2;
        base = (base * base) % mod;
    }
    return result;
}

long long comb(int n, int r) {
    if (r > n || r < 0) return 0;
    if (r == 0 || r == n) return 1;
    
    long long numerator = 1;
    long long denominator = 1;
    int k = (r < n - r) ? r : n - r;
    
    for (int i = 0; i < k; i++) {
        numerator = (numerator * (n - i)) % MOD;
        denominator = (denominator * (i + 1)) % MOD;
    }
    
    return (numerator * modPow(denominator, MOD - 2, MOD)) % MOD;
}

int countSubsequences(int* nums, int n) {
    long long count = 0;
    
    for (int mid = 2; mid < n - 2; mid++) {
        int middleVal = nums[mid];
        
        int leftCount[MAXN] = {0};
        int rightCount[MAXN] = {0};
        
        for (int i = 0; i < mid; i++) {
            leftCount[nums[i]]++;
        }
        
        for (int i = mid + 1; i < n; i++) {
            rightCount[nums[i]]++;
        }
        
        int leftMiddle = leftCount[middleVal];
        int rightMiddle = rightCount[middleVal];
        
        for (int pickLeftMiddle = 0; pickLeftMiddle <= (leftMiddle < 2 ? leftMiddle : 2); pickLeftMiddle++) {
            for (int pickRightMiddle = 0; pickRightMiddle <= (rightMiddle < 2 ? rightMiddle : 2); pickRightMiddle++) {
                if (pickLeftMiddle + pickRightMiddle > 2) continue;
                
                int currentMiddleCount = 1 + pickLeftMiddle + pickRightMiddle;
                int remainingLeft = 2 - pickLeftMiddle;
                int remainingRight = 2 - pickRightMiddle;
                
                if (remainingLeft < 0 || remainingRight < 0) continue;
                
                long long waysLeftMiddle = comb(leftMiddle, pickLeftMiddle);
                long long waysRightMiddle = comb(rightMiddle, pickRightMiddle);
                
                if (remainingLeft == 0 && remainingRight == 0) {
                    count = (count + waysLeftMiddle * waysRightMiddle) % MOD;
                } else {
                    int leftOthers = 0, rightOthers = 0;
                    
                    for (int i = 0; i < MAXN; i++) {
                        if (i != middleVal) {
                            leftOthers += leftCount[i];
                            rightOthers += rightCount[i];
                        }
                    }
                    
                    if (leftOthers >= remainingLeft && rightOthers >= remainingRight) {
                        long long waysLeftOthers = comb(leftOthers, remainingLeft);
                        long long waysRightOthers = comb(rightOthers, remainingRight);
                        
                        int maxOther = (remainingLeft > remainingRight) ? remainingLeft : remainingRight;
                        maxOther = (maxOther > 1) ? maxOther : 1;
                        
                        if (currentMiddleCount > maxOther) {
                            long long totalWays = (waysLeftMiddle * waysRightMiddle) % MOD;
                            totalWays = (totalWays * waysLeftOthers) % MOD;
                            totalWays = (totalWays * waysRightOthers) % MOD;
                            count = (count + totalWays) % MOD;
                        }
                    }
                }
            }
        }
    }
    
    return count;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int n = 0;
    
    char* token = strtok(line, "[,]\n");
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, "[,]\n");
    }
    
    printf("%d\n", countSubsequences(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each position, count elements in left/right subarrays

⚠ Quadratic Growth

Space Complexity

O(n)

Hash maps to store element counts and positions

⚡ Linearithmic Space

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Combinatorial Count (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler