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. You may partition nums into one or more subsequences such that each element in nums appears in exactly one of the subsequences.

Return the minimum number of subsequences needed such that the difference between the maximum and minimum values in each subsequence is at most k.

A subsequence is a sequence that can be derived from another sequence by deleting some or no elements without changing the order of the remaining elements.

Input & Output

Example 1 — Basic Case

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

› Output: 2

💡 Note: After sorting [1,2,4,6], we can partition into {1,2} (diff=1≤2) and {4,6} (diff=2≤2). Need 2 subsequences.

Example 2 — Single Subsequence

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

› Output: 1

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

Example 3 — All Separate

$ Input: nums = [1,4,7,10], k = 2

› Output: 4

💡 Note: Each element needs its own subsequence since consecutive differences are all > 2.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 18 a Amazon 15

The key insight is that sorting the array first allows us to use a greedy approach. After sorting, we only need to track the minimum element of the current subsequence and start a new subsequence when the difference exceeds k. Best approach is the greedy method with Time: O(n log n), Space: O(1).

Common Approaches

✓ Brute Force - Try All Partitions

⏱️ Time: O(2^n) Space: O(n)

Try every possible way to partition the array into subsequences, check if each subsequence has max-min ≤ k, and return the minimum number of subsequences needed.

Greedy Approach After Sorting

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

Sort the array to bring similar values together. Then iterate through sorted array, starting new subsequences only when the difference between current element and the minimum of current subsequence exceeds k.

Brute Force - Try All Partitions — Algorithm Steps

Generate all possible partitions of the array
For each partition, check if all subsequences satisfy max-min ≤ k
Track the minimum number of valid subsequences

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Partitions

Try every possible way to group elements

Validate Groups

Check if max-min ≤ k in each group

Find Minimum

Return the grouping with fewest subsequences

Code -

solution.c — C

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

int minPartitions = INT_MAX;

void backtrack(int index, int* nums, int n, int k, int** partitions, int* partitionSizes, int numPartitions) {
    if (index == n) {
        int valid = 1;
        int nonEmptyCount = 0;
        for (int i = 0; i < numPartitions; i++) {
            if (partitionSizes[i] > 0) {
                nonEmptyCount++;
                int minVal = partitions[i][0], maxVal = partitions[i][0];
                for (int j = 1; j < partitionSizes[i]; j++) {
                    if (partitions[i][j] < minVal) minVal = partitions[i][j];
                    if (partitions[i][j] > maxVal) maxVal = partitions[i][j];
                }
                if (maxVal - minVal > k) {
                    valid = 0;
                    break;
                }
            }
        }
        if (valid && nonEmptyCount < minPartitions) {
            minPartitions = nonEmptyCount;
        }
        return;
    }
    
    // Try adding current element to each existing partition
    for (int i = 0; i < numPartitions; i++) {
        partitions[i][partitionSizes[i]] = nums[index];
        partitionSizes[i]++;
        backtrack(index + 1, nums, n, k, partitions, partitionSizes, numPartitions);
        partitionSizes[i]--;
    }
    
    // Try creating a new partition (simplified for this implementation)
    if (numPartitions < n) {
        partitions[numPartitions][0] = nums[index];
        partitionSizes[numPartitions] = 1;
        backtrack(index + 1, nums, n, k, partitions, partitionSizes, numPartitions + 1);
        partitionSizes[numPartitions] = 0;
    }
}

int solution(int* nums, int n, int k) {
    minPartitions = INT_MAX;
    int** partitions = (int**)malloc(n * sizeof(int*));
    int* partitionSizes = (int*)calloc(n, sizeof(int));
    for (int i = 0; i < n; i++) {
        partitions[i] = (int*)malloc(n * sizeof(int));
    }
    
    backtrack(0, nums, n, k, partitions, partitionSizes, 0);
    
    for (int i = 0; i < n; i++) {
        free(partitions[i]);
    }
    free(partitions);
    free(partitionSizes);
    
    return minPartitions;
}

int main() {
    char buffer[1000];
    fgets(buffer, sizeof(buffer), stdin);
    
    int nums[100];
    int n = 0;
    char* token = strtok(buffer, "[,]");
    while (token != NULL) {
        if (token[0] >= '0' && token[0] <= '9' || token[0] == '-') {
            nums[n++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int k;
    scanf("%d", &k);
    
    printf("%d\n", solution(nums, n, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

Need to check all possible ways to partition n elements into subsequences

⚡ Linearithmic

Space Complexity

O(n)

Recursion stack depth and temporary storage for partitions

✓ Linear Space

23.4K Views

Medium Frequency

~15 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Partitions — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler