Subarrays Distinct Element Sum of Squares II - Problem

You are given a 0-indexed integer array nums. The distinct count of a subarray is defined as follows:

Let nums[i..j] be a subarray of nums consisting of all indices from i to j such that 0 <= i <= j < nums.length. The number of distinct values in nums[i..j] is called the distinct count of nums[i..j].

Return the sum of squares of distinct counts of all subarrays of nums. Since the answer may be very large, return it modulo 10^9 + 7.

A subarray is a contiguous non-empty sequence of elements within an array.

Input & Output

Example 1 — Basic Case

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

› Output: 15

💡 Note: All subarrays: [1](1²=1), [2](1²=1), [1](1²=1), [1,2](2²=4), [2,1](2²=4), [1,2,1](2²=4). Sum = 1+1+1+4+4+4 = 15

Example 2 — All Different

$ Input: nums = [1,2]

› Output: 6

💡 Note: Subarrays: [1](1²=1), [2](1²=1), [1,2](2²=4). Sum = 1+1+4 = 6

Example 3 — Single Element

$ Input: nums = [5]

› Output: 1

💡 Note: Only one subarray [5] with 1 distinct element: 1² = 1

Constraints

1 ≤ nums.length ≤ 100
1 ≤ nums[i] ≤ 100

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 20 a Amazon 15

The key insight is to efficiently count distinct elements in all subarrays. The optimized approach uses incremental set building to avoid redundant counting. Best approach has Time: O(n²), Space: O(n) using sets for distinct element tracking.

Common Approaches

✓ Brute Force

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

For each possible subarray, use a set to count distinct elements, square the count, and add to result. This directly implements the problem definition.

Optimized with Set Tracking

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

For each starting position, incrementally build subarrays and maintain a set of distinct elements. This avoids recounting from scratch for each subarray.

Brute Force — Algorithm Steps

Generate all possible subarrays [i,j]
For each subarray, count distinct elements using a set
Square the distinct count and add to total sum

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subarrays

Create all possible contiguous subarrays

Count Distinct

Use set to count unique elements in each subarray

Square and Sum

Square each count and add to total

Code -

solution.c — C

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

int solution(int* nums, int numsSize) {
    const int MOD = 1000000007;
    long long total = 0;
    
    for (int i = 0; i < numsSize; i++) {
        for (int j = i; j < numsSize; j++) {
            int distinct[1001] = {0};
            int distinctCount = 0;
            
            for (int k = i; k <= j; k++) {
                if (distinct[nums[k] + 500] == 0) {
                    distinct[nums[k] + 500] = 1;
                    distinctCount++;
                }
            }
            
            total = (total + (long long)distinctCount * distinctCount) % MOD;
        }
    }
    
    return (int)total;
}

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);
    
    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³)

Three nested loops: O(n²) subarrays × O(n) to count distinct elements

⚠ Quadratic Growth

Space Complexity

O(n)

Set to store distinct elements in current subarray

⚡ Linearithmic Space

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

Subarrays Distinct Element Sum of Squares II - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler