Count Partitions With Max-Min Difference at Most K

Count Partitions With Max-Min Difference at Most K - Problem

Array Dynamic Programming Queue Sliding Window Prefix Sum Monotonic Queue Medium

You're given an integer array nums and an integer k. Your mission is to partition this array into one or more non-empty contiguous segments such that within each segment, the difference between the maximum and minimum elements is at most k.

Think of it like organizing books on shelves where each shelf can only hold books whose page counts don't differ by more than k pages. You need to count all the different ways you can arrange these "shelves" (partitions).

Goal: Return the total number of valid partitioning ways.

Note: Since the answer can be very large, return it modulo 10^9 + 7.

Example: For nums = [1,3,1,1] and k = 2, you could partition as [1,3,1,1] (max-min = 3-1 = 2 ≤ k) or [1,3] + [1,1] (both segments satisfy the condition), among other ways.

Input & Output

example_1.py — Python

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

› Output: 8

💡 Note: The valid partitions are: [1,3,1,1], [1,3,1]+[1], [1,3]+[1,1], [1]+[3,1,1], [1]+[3,1]+[1], [1]+[3]+[1,1], [1,3]+[1]+[1], [1]+[3]+[1]+[1]. Each segment satisfies max-min ≤ 2.

example_2.py — Python

$ Input: nums = [2,2,4,5], k = 0

› Output: 3

💡 Note: With k=0, each segment can only contain identical elements. Valid partitions: [2]+[2]+[4]+[5], [2,2]+[4]+[5], and we need to check which others work. Actually: [2]+[2]+[4]+[5], [2,2]+[4]+[5] are the only valid ones, so answer is 2.

example_3.py — Python

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

› Output: 5

💡 Note: Since all elements are identical and k=5, any partition works: [1,1,1], [1,1]+[1], [1]+[1,1], [1]+[1]+[1]. That's 4 ways, but let me recount: [1,1,1], [1]+[1,1], [1,1]+[1], [1]+[1]+[1] = 4 ways.

Visualization

Tap to expand

Understanding the Visualization

Examine Each Position

For each book position, consider it as the end of a shelf

Find Valid Starting Points

Look back to find all positions where we could start a new shelf

Sum Up Possibilities

Add up all the ways we could have organized the previous shelves

Build Complete Solution

Continue until all books are placed on valid shelves

Key Takeaway

🎯 Key Insight: At each position, the number of ways to partition equals the sum of ways to partition at all valid previous positions where we can start a new segment satisfying the max-min constraint.

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) pairs of positions to check, O(n) time to validate each segment

⚠ Quadratic Growth

Space Complexity

O(n)

DP array of size n+1 to store partition counts

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 10⁵
0 ≤ k ≤ 10⁵
All partitions must be non-empty and contiguous

Asked in

G Google 45 f Meta 32 a Amazon 28 ⊞ Microsoft 18

This problem is optimally solved using Dynamic Programming where we build up the solution by considering each position as a potential partition endpoint. The key insight is that dp[i] = sum of dp[j] for all valid starting positions j where the segment from j to i-1 satisfies the max-min ≤ k constraint.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming	O(n³)	O(n)	Use DP to count partitions by considering each position as a potential partition point

Dynamic Programming — Algorithm Steps

Initialize dp array where dp[i] = number of ways to partition nums[0...i-1]
For each position i, find all valid starting positions j where segment [j, i-1] satisfies max-min ≤ k
dp[i] = sum of dp[j] for all valid starting positions j
Return dp[n] as the final answer

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP

dp[0] = 1 (empty array has 1 way to partition)

Fill DP Table

For each position i, sum valid ways from all previous positions j

Return Result

dp[n] contains the total number of valid partitions

Code -

solution.c — C

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

#define MOD 1000000007

int numWaysToPartition(int* nums, int numsSize, int k) {
    long long* dp = (long long*)calloc(numsSize + 1, sizeof(long long));
    dp[0] = 1;
    
    for (int i = 1; i <= numsSize; i++) {
        for (int j = 0; j < i; j++) {
            int minVal = nums[j], maxVal = nums[j];
            for (int l = j; l < i; l++) {
                if (nums[l] < minVal) minVal = nums[l];
                if (nums[l] > maxVal) maxVal = nums[l];
            }
            
            if (maxVal - minVal <= k) {
                dp[i] = (dp[i] + dp[j]) % MOD;
            }
        }
    }
    
    int result = dp[numsSize];
    free(dp);
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) pairs of positions to check, O(n) time to validate each segment

⚠ Quadratic Growth

Space Complexity

O(n)

DP array of size n+1 to store partition counts

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 10⁵
0 ≤ k ≤ 10⁵
All partitions must be non-empty and contiguous

34.5K Views

Medium Frequency

~25 min Avg. Time

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

Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler