Sum of Imbalance Numbers of All Subarrays

Sum of Imbalance Numbers of All Subarrays - Problem

Imagine you're analyzing the stability of different sections of a data stream. The imbalance number of an array measures how many "gaps" exist when elements are sorted.

Given an array nums, for each possible subarray, we need to:

Sort the subarray elements
Count gaps where consecutive sorted elements differ by more than 1
Sum all these gap counts across all subarrays

For example, in sorted array [1, 3, 7], there are 2 gaps: between 1→3 (diff=2) and 3→7 (diff=4).

Goal: Return the total sum of imbalance numbers for all possible contiguous subarrays.

Input & Output

example_1.py — Basic Case

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

› Output: 6

💡 Note: All subarrays: [2]=0, [2,3]=0, [2,3,1]=0, [2,3,1,4]=0, [3]=0, [3,1]=1, [3,1,4]=1, [1]=0, [1,4]=1, [4]=0. Subarray [3,1] sorted is [1,3], gap 3-1=2>1, so 1 imbalance. Similarly [3,1,4]→[1,3,4] has gap 3-1=2>1, and [1,4] has gap 4-1=3>1. Total: 1+1+1+3=6.

example_2.py — Sequential Numbers

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

› Output: 8

💡 Note: Most subarrays containing both 1 and 3 have gap 3-1=2>1 (1 imbalance). Subarrays containing both 3 and 5 have gap 5-3=2>1 (1 imbalance). Duplicates don't create additional gaps in sorted arrays.

example_3.py — Single Element

$ Input: [1]

› Output: 0

💡 Note: Only one subarray [1], which has no consecutive elements, so 0 imbalances.

Visualization

Tap to expand

Understanding the Visualization

Identify Gaps

Find where elevation jumps by more than 1 unit

Count Efficiently

Use math to avoid generating all combinations

Sum Contributions

Add up gap counts from all trail sections

Key Takeaway

🎯 Key Insight: Rather than generating all O(n²) subarrays and sorting each one, we can mathematically calculate how many times each element contributes to imbalances across all possible subarrays, reducing complexity significantly.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each element, we calculate its contribution across all subarrays containing it

⚠ Quadratic Growth

Space Complexity

O(n)

Extra space for tracking element positions and contributions

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ nums.length
All subarrays must be contiguous

Asked in

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

The optimal solution uses mathematical contribution counting instead of generating all subarrays. For each starting position, we extend the subarray one element at a time and track how the imbalance count changes incrementally. When adding a new element, we check if it creates gaps (no adjacent neighbors), fills gaps (both neighbors exist), or maintains current imbalance. This achieves O(n²) time complexity compared to the brute force O(n³ log n).

Common Approaches

Approach	Time	Space	Notes
✓ Mathematical Contribution Counting (Optimal)	O(n²)	O(n)	Count each element's contribution to gaps across all subarrays mathematically
Brute Force (Generate All Subarrays)	O(n³ log n)	O(n)	Generate all subarrays, sort each one, and count imbalances

Mathematical Contribution Counting (Optimal) — Algorithm Steps

For each element, determine its contribution to imbalances
Count how many subarrays where this element creates a gap
Use mathematical formulas to avoid generating actual subarrays
Sum all contributions efficiently

Visualization

Tap to expand

Step-by-Step Walkthrough

Track Elements

For each subarray extension, track which elements we've seen

Calculate Impact

Determine if new element creates, removes, or maintains imbalances

Sum Contributions

Add imbalance count for current subarray to total

Code -

solution.c — C

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

#define MAX_VAL 2000

int sumImbalanceNumbers(int* nums, int numsSize) {
    int result = 0;
    
    // For each starting position
    for (int i = 0; i < numsSize; i++) {
        bool seen[MAX_VAL + 5] = {false}; // Accommodate negative indexing
        int imbalance = 0;
        
        // Extend subarray from position i
        for (int j = i; j < numsSize; j++) {
            int x = nums[j] + 1000; // Offset for array indexing
            
            // Add current element to seen set
            if (!seen[x]) {
                seen[x] = true;
                
                // Check if adding x creates or removes imbalances
                bool leftExists = (x > 0) && seen[x - 1];
                bool rightExists = (x < MAX_VAL) && seen[x + 1];
                
                if (leftExists && rightExists) {
                    // x fills a gap, reduces imbalance by 1
                    imbalance--;
                } else if (!leftExists && !rightExists) {
                    // x creates a new gap
                    imbalance++;
                }
                // If exactly one neighbor exists, imbalance stays same
            }
            
            result += imbalance;
        }
    }
    
    return result;
}

int main() {
    int nums[] = {2, 3, 1, 4};
    printf("%d\n", sumImbalanceNumbers(nums, 4));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each element, we calculate its contribution across all subarrays containing it

⚠ Quadratic Growth

Space Complexity

O(n)

Extra space for tracking element positions and contributions

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ nums.length
All subarrays must be contiguous

28.9K Views

Medium Frequency

~25 min Avg. Time

867 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Mathematical Contribution Counting (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler