Partition Array Such That Maximum Difference Is K

Partition Array Such That Maximum Difference Is K - Problem

You are given an integer array nums and an integer k. Your task is to partition the array into the minimum number of subsequences such that:

Each element appears in exactly one subsequence
The difference between the maximum and minimum values in each subsequence is at most k

A subsequence maintains the relative order of elements from the original array (you can skip elements but cannot rearrange them).

Example: If nums = [3,6,1,2,5] and k = 2, you could create subsequences [3,1,2] (max-min = 3-1 = 2 ≤ k) and [6,5] (max-min = 6-5 = 1 ≤ k), giving us 2 subsequences total.

Return the minimum number of subsequences needed to satisfy these conditions.

Input & Output

example_1.py — Basic case

$ Input: nums = [3,6,1,2,5], k = 2

› Output: 2

💡 Note: We can partition into [3,1,2] (max-min = 3-1 = 2 ≤ k) and [6,5] (max-min = 6-5 = 1 ≤ k). Total: 2 subsequences.

example_2.py — All elements fit in one

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

› Output: 1

💡 Note: All elements can fit in one subsequence [1,2,3] since max-min = 3-1 = 2 ≤ k.

example_3.py — Each element needs own subsequence

$ Input: nums = [1,10,20], k = 5

› Output: 3

💡 Note: Each element needs its own subsequence: [1], [10], [20] since any pair would exceed k=5.

Visualization

Tap to expand

Understanding the Visualization

First musician (skill 3)

Create first section with skill range [3,3]

Second musician (skill 6)

Gap would be 6-3=3 > k=2, so create new section [6,6]

Third musician (skill 1)

Can join first section, range becomes [1,3] with gap 2≤k

Continue process

Each musician joins the earliest section they can fit in, or starts a new section

Key Takeaway

🎯 Key Insight: The greedy approach works because we must maintain order - once we decide whether to add an element to an existing subsequence or start a new one, that decision doesn't affect future optimal choices.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each element, we might check all existing subsequences in worst case

⚠ Quadratic Growth

Space Complexity

O(n)

Space to store information about active subsequences

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ k ≤ 10⁵
1 ≤ nums[i] ≤ 10⁵
Elements must maintain their relative order from the original array

Asked in

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

The optimal solution uses a greedy approach that processes elements in order, maintaining active subsequences with their min/max values. For each element, we try to add it to an existing subsequence where the constraint max-min ≤ k remains satisfied. If no such subsequence exists, we start a new one. This greedy strategy is optimal because delaying the creation of a new subsequence never benefits us due to the order constraint.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Approach (Optimal)	O(n²)	O(n)	Greedily start new subsequences when current ones can't accommodate the next element
Brute Force (Try All Partitions)	O(2^n × n)	O(n)	Generate all possible ways to partition the array and find the minimum valid partition count

Greedy Approach (Optimal) — Algorithm Steps

Initialize an empty list to track active subsequences
For each element in the array, try to find a subsequence where adding this element keeps max-min ≤ k
If such a subsequence exists, add the element to it
Otherwise, start a new subsequence with this element
Return the total number of subsequences created

Visualization

Tap to expand

Step-by-Step Walkthrough

Process element 3

Start first subsequence [3,3] (min=3, max=3)

Process element 6

6-3=3 > k=2, so start new subsequence [6,6]

Process element 1

Add 1 to first subsequence, now [1,3] (min=1, max=3, diff=2≤k)

Process element 2

Can add 2 to first subsequence [1,3], diff remains 2≤k

Code -

solution.c — C

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

typedef struct {
    int min;
    int max;
} Subsequence;

int min(int a, int b) {
    return a < b ? a : b;
}

int max(int a, int b) {
    return a > b ? a : b;
}

int partitionArray(int* nums, int numsSize, int k) {
    Subsequence* subsequences = (Subsequence*)malloc(numsSize * sizeof(Subsequence));
    int count = 0;
    
    for (int i = 0; i < numsSize; i++) {
        int added = 0;
        
        // Try to add to existing subsequence
        for (int j = 0; j < count; j++) {
            int newMin = min(subsequences[j].min, nums[i]);
            int newMax = max(subsequences[j].max, nums[i]);
            
            if (newMax - newMin <= k) {
                subsequences[j].min = newMin;
                subsequences[j].max = newMax;
                added = 1;
                break;
            }
        }
        
        // Start new subsequence if needed
        if (!added) {
            subsequences[count].min = nums[i];
            subsequences[count].max = nums[i];
            count++;
        }
    }
    
    free(subsequences);
    return count;
}

int main() {
    int nums[] = {3, 6, 1, 2, 5};
    int k = 2;
    printf("%d\n", partitionArray(nums, 5, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each element, we might check all existing subsequences in worst case

⚠ Quadratic Growth

Space Complexity

O(n)

Space to store information about active subsequences

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ k ≤ 10⁵
1 ≤ nums[i] ≤ 10⁵
Elements must maintain their relative order from the original array

23.7K Views

Medium Frequency

~12 min Avg. Time

842 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

Greedy Approach (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler