Find the Median of the Uniqueness Array - Problem

You are given an integer array nums. The uniqueness array of nums is the sorted array that contains the number of distinct elements of all the subarrays of nums.

In other words, it is a sorted array consisting of distinct(nums[i..j]), for all 0 <= i <= j < nums.length. Here, distinct(nums[i..j]) denotes the number of distinct elements in the subarray that starts at index i and ends at index j.

Return the median of the uniqueness array of nums.

Note that the median of an array is defined as the middle element of the array when it is sorted in non-decreasing order. If there are two choices for a median, the smaller of the two values is taken.

Input & Output

Example 1 — Basic Case

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

› Output: 2

💡 Note: All subarrays: [1]=1, [1,2]=2, [1,2,1]=2, [1,2,1,3]=3, [2]=1, [2,1]=2, [2,1,3]=3, [1]=1, [1,3]=2, [3]=1. Uniqueness array: [1,1,1,1,2,2,2,2,3,3]. Median is 2.

Example 2 — All Same Elements

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

› Output: 1

💡 Note: All subarrays: [3]=1, [3,3]=1, [3,3,3]=1, [3]=1, [3,3]=1, [3]=1. Uniqueness array: [1,1,1,1,1,1]. Median is 1.

Example 3 — All Different Elements

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

› Output: 1

💡 Note: All subarrays: [1]=1, [1,2]=2, [1,2,3]=3, [2]=1, [2,3]=2, [3]=1. Uniqueness array: [1,1,1,2,2,3]. Median is 1.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8

The key insight is to use binary search on the answer space instead of generating all uniqueness values. The optimal approach uses binary search on median value combined with sliding window technique to efficiently count subarrays. Time: O(n² log n), Space: O(n)

Common Approaches

✓ Binary Search on Answer

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

Instead of generating all uniqueness values, binary search on the possible median values (1 to n). For each candidate, use sliding window to count how many subarrays have uniqueness ≤ candidate.

Generate All Uniqueness Values

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

For each possible subarray, count distinct elements using a set. Store all counts in an array, sort it, and return the median element.

Binary Search on Answer — Algorithm Steps

Binary search on possible uniqueness values (1 to n)
For each candidate, use sliding window to count subarrays with uniqueness ≤ candidate
If count ≥ half of total subarrays, try smaller values, otherwise try larger

Visualization

Tap to expand

Step-by-Step Walkthrough

Binary Search

Search median value in range [1, n]

Count Subarrays

Use sliding window to count subarrays ≤ candidate

Adjust Range

Narrow search based on count vs target

Code -

solution.c — C

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

typedef struct {
    int key;
    int value;
} HashEntry;

typedef struct {
    HashEntry entries[10000];
    int size;
} HashMap;

int hashGet(HashMap* map, int key) {
    for (int i = 0; i < map->size; i++) {
        if (map->entries[i].key == key) {
            return map->entries[i].value;
        }
    }
    return 0;
}

void hashPut(HashMap* map, int key, int value) {
    for (int i = 0; i < map->size; i++) {
        if (map->entries[i].key == key) {
            map->entries[i].value = value;
            return;
        }
    }
    map->entries[map->size].key = key;
    map->entries[map->size].value = value;
    map->size++;
}

long long countSubarraysWithUniquenessAtMost(int* nums, int numsSize, int k) {
    long long count = 0;
    int left = 0;
    HashMap freq = {0};
    int distinct = 0;
    
    for (int right = 0; right < numsSize; right++) {
        if (hashGet(&freq, nums[right]) == 0) {
            distinct++;
        }
        hashPut(&freq, nums[right], hashGet(&freq, nums[right]) + 1);
        
        while (distinct > k) {
            int leftVal = hashGet(&freq, nums[left]);
            hashPut(&freq, nums[left], leftVal - 1);
            if (leftVal - 1 == 0) {
                distinct--;
            }
            left++;
        }
        
        count += right - left + 1;
    }
    
    return count;
}

int solution(int* nums, int numsSize) {
    long long totalSubarrays = (long long) numsSize * (numsSize + 1) / 2;
    long long target = (totalSubarrays + 1) / 2;
    
    int left = 1, right = numsSize;
    while (left < right) {
        int mid = (left + right) / 2;
        if (countSubarraysWithUniquenessAtMost(nums, numsSize, mid) >= target) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }
    
    return left;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n² log n)

O(log n) binary search iterations, each requiring O(n²) sliding window counting

⚠ Quadratic Growth

Space Complexity

O(n)

Hash map for tracking distinct elements in sliding window

⚠ Quadratic Space

12.0K Views

Medium Frequency

~35 min Avg. Time

450 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

Find the Median of the Uniqueness Array - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Binary Search on Answer — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler