Subarrays Distinct Element Sum of Squares I

Subarrays Distinct Element Sum of Squares I - Problem

Subarray Analysis: You are given a 0-indexed integer array nums. Your task is to analyze all possible subarrays and calculate a special metric based on their distinct elements.

For each subarray nums[i..j] (where 0 ≤ i ≤ j < nums.length), you need to:
1. Count the number of distinct values in that subarray
2. Square that count
3. Add it to your final result

Goal: Return the sum of squares of distinct counts for all possible subarrays.

Example: For [1,2,1], subarrays are [1], [2], [1], [1,2], [2,1], [1,2,1] with distinct counts 1, 1, 1, 2, 2, 2. Sum of squares = 1² + 1² + 1² + 2² + 2² + 2² = 15.

Input & Output

example_1.py — Basic Case

$ Input: [1,2,1]

› Output: 15

💡 Note: Subarrays: [1](distinct=1,square=1), [2](distinct=1,square=1), [1](distinct=1,square=1), [1,2](distinct=2,square=4), [2,1](distinct=2,square=4), [1,2,1](distinct=2,square=4). Total: 1+1+1+4+4+4=15

example_2.py — All Same Elements

$ Input: [1,1,1]

› Output: 6

💡 Note: All subarrays have exactly 1 distinct element. There are 6 subarrays total: [1], [1], [1], [1,1], [1,1], [1,1,1]. Each contributes 1² = 1, so total is 6.

example_3.py — All Different Elements

$ Input: [1,2,3]

› Output: 20

💡 Note: Subarrays: [1](1²=1), [2](1²=1), [3](1²=1), [1,2](2²=4), [2,3](2²=4), [1,2,3](3²=9). Total: 1+1+1+4+4+9=20

Constraints

1 ≤ nums.length ≤ 100
1 ≤ nums[i] ≤ 100
The result will fit in a 32-bit integer

Visualization

Tap to expand

Understanding the Visualization

Choose Starting Shelf

Pick a starting position in the library shelf

Extend Section

Gradually include more books while tracking unique genres

Calculate Diversity Score

Square the number of unique genres to emphasize diversity

Repeat for All Sections

Do this for every possible shelf section and sum all scores

Key Takeaway

🎯 Key Insight: By fixing the starting position and extending subarrays incrementally while maintaining a hash set, we efficiently calculate distinct counts without redundant work, achieving optimal O(n²) time complexity for this subarray enumeration problem.

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal approach uses nested loops with incremental subarray extension. For each starting position, we maintain a hash set of distinct elements and extend the subarray one element at a time. This achieves O(n²) time complexity while being simple to implement and understand.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Triple Nested Loops)	O(n³)	O(n)	Generate all subarrays, count distinct elements in each using a set
Optimized Nested Loops	O(n²)	O(n)	For each start position, extend subarrays incrementally while maintaining distinct count

Brute Force (Triple Nested Loops) — Algorithm Steps

Iterate through all starting positions i from 0 to n-1
For each i, iterate through all ending positions j from i to n-1
For each subarray [i,j], use a set to count distinct elements
Square the distinct count and add to total result

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subarrays

For each starting position i, generate all subarrays ending at j ≥ i

Count Distinct

Use a hash set to count unique elements in each subarray

Square and Sum

Square the distinct count and add to running total

Code -

solution.c — C

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

int sumOfSquares(int* nums, int n) {
    int total = 0;
    
    // Generate all subarrays
    for (int i = 0; i < n; i++) {
        for (int j = i; j < n; j++) {
            // Count distinct elements in subarray [i,j]
            int distinct[1001] = {0}; // Assuming values <= 1000
            int distinctCount = 0;
            
            for (int k = i; k <= j; k++) {
                if (distinct[nums[k]] == 0) {
                    distinct[nums[k]] = 1;
                    distinctCount++;
                }
            }
            
            // Square the count and add to total
            total += distinctCount * distinctCount;
        }
    }
    
    return total;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) for all subarray pairs, O(n) to count distinct elements in each subarray

⚠ Quadratic Growth

Space Complexity

O(n)

O(n) for the hash set to store distinct elements in worst case

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~15 min Avg. Time

892 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 (Triple Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler