Minimum Increment Operations to Make Array Beautiful

Minimum Increment Operations to Make Array Beautiful - Problem

You're given an array of integers and need to make it beautiful with the minimum number of increment operations.

An array is considered beautiful if every subarray of length 3 or more contains at least one element that is >= k. In each operation, you can choose any index and increase that element by 1.

Goal: Return the minimum number of increment operations needed to make the array beautiful.

Example: If nums = [2, 3, 0, 0, 2] and k = 4, you need to ensure that every window of size 3+ has at least one element >= 4. The subarrays [2,3,0], [3,0,0], [0,0,2], [2,3,0,0], etc. must each contain at least one element >= 4.

Input & Output

example_1.py — Basic Case

$ Input: [2, 3, 0, 0, 2], k = 4

› Output: 7

💡 Note: We need to increment: position 0 by 2 (2→4), position 1 by 1 (3→4), and position 3 by 4 (0→4). This ensures every subarray of length 3+ has at least one element ≥ 4. Total operations: 2 + 1 + 4 = 7.

example_2.py — Minimal Increments

$ Input: [0, 1, 3, 3], k = 5

› Output: 2

💡 Note: We only need to increment position 2 by 2 (3→5). This satisfies the constraint as subarray [0,1,3] contains 5, and [1,3,3] contains 5. Total operations: 2.

example_3.py — All Elements Large

$ Input: [10, 20, 15], k = 5

› Output: 0

💡 Note: All elements are already ≥ 5, so the array is already beautiful. No operations needed.

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁹
1 ≤ k ≤ 10⁹
Key insight: Only subarrays of length 3 or more need to be considered

Visualization

Tap to expand

Understanding the Visualization

Identify Coverage Gaps

Find subarrays of length 3+ that don't have any element ≥ k

Strategic Placement

Use DP to decide optimal positions for increments, considering coverage overlap

Minimize Total Cost

Choose increment positions that minimize total operations while ensuring full coverage

Key Takeaway

🎯 Key Insight: Use dynamic programming to track the minimum cost of maintaining coverage, where at most one increment every 3 positions is sufficient to satisfy all constraints.

Asked in

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

The optimal solution uses dynamic programming to track the minimum cost while ensuring coverage constraints. The key insight is that we only need to ensure one of every 3 consecutive positions has a value ≥ k. We maintain DP states representing the minimum operations when the last increment was at different relative positions, allowing us to make optimal decisions at each step in O(n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(n)	O(1)	Use DP to track minimum cost ensuring coverage constraints are satisfied
Brute Force (Try All Combinations)	O(k^n)	O(k^n)	Try all possible ways to increment elements until the array becomes beautiful

Dynamic Programming (Optimal) — Algorithm Steps

Initialize DP state: dp[i][mask] = min operations for first i elements with mask indicating which of last 3 positions are >= k
For each position, try keeping original value or incrementing to k
Check that every window of size 3 has at least one element >= k
Return minimum operations for valid final states

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize States

Set up DP states tracking last increment positions

Process Each Position

For each position, decide whether to increment or rely on previous coverage

Update States

Update DP states based on current decision and maintain optimal costs

Code -

solution.c — C

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

long long min3(long long a, long long b, long long c) {
    long long min_ab = (a < b) ? a : b;
    return (min_ab < c) ? min_ab : c;
}

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

long long minIncrementOperations(int* nums, int n, int k) {
    if (n < 3) return 0;
    
    // dp[0] = min cost with last increment at position i-2 or earlier
    // dp[1] = min cost with last increment at position i-1  
    // dp[2] = min cost with last increment at position i
    
    long long dp[3] = {0, 0, 0};
    dp[2] = max(0, k - nums[0]); // Must increment first position
    
    for (int i = 1; i < n; i++) {
        long long incrementCost = max(0, k - nums[i]);
        long long newDp[3] = {0, 0, 0};
        
        // Option 1: Increment current position
        newDp[2] = min3(dp[0], dp[1], dp[2]) + incrementCost;
        
        // Option 2: Don't increment (shift previous states)
        if (i >= 2) {
            newDp[1] = dp[2]; // Previous increment becomes i-1
            newDp[0] = dp[1]; // Previous increment becomes i-2
        } else {
            newDp[1] = (i == 1) ? dp[2] : LLONG_MAX;
            newDp[0] = LLONG_MAX;
        }
        
        dp[0] = newDp[0];
        dp[1] = newDp[1];
        dp[2] = newDp[2];
    }
    
    return min3(dp[0], dp[1], dp[2]);
}

int main() {
    int n, k;
    scanf("%d %d", &n, &k);
    int* nums = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        scanf("%d", &nums[i]);
    }
    
    printf("%lld\n", minIncrementOperations(nums, n, k));
    free(nums);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array with constant time operations per element

✓ Linear Growth

Space Complexity

O(1)

Only need to track the last 3 DP states, not the entire array

✓ Linear Space

28.4K Views

Medium Frequency

~25 min Avg. Time

856 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

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler