Minimum Operations to Make the Array Increasing

Minimum Operations to Make the Array Increasing - Problem

Array Greedy Easy

You are given an integer array nums (0-indexed). In one operation, you can choose an element of the array and increment it by 1.

For example, if nums = [1,2,3], you can choose to increment nums[1] to make nums = [1,3,3].

Return the minimum number of operations needed to make nums strictly increasing.

An array nums is strictly increasing if nums[i] < nums[i+1] for all 0 <= i < nums.length - 1. An array of length 1 is trivially strictly increasing.

Input & Output

Example 1 — Basic Case

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

› Output: 3

💡 Note: After 3 operations: [1,2,3]. Operations: increment nums[1] to 2 (1 op), increment nums[2] to 3 (2 ops).

Example 2 — Partially Sorted

$ Input: nums = [1,5,2,4,1]

› Output: 14

💡 Note: Transform to [1,5,6,7,8]. Operations: nums[2]: 2→6 (4 ops), nums[3]: 4→7 (3 ops), nums[4]: 1→8 (7 ops). Total: 14.

Example 3 — Already Sorted

$ Input: nums = [8]

› Output: 0

💡 Note: Single element array is already strictly increasing, no operations needed.

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 1000

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 f Facebook 8

The key insight is that we only need to ensure each element is strictly greater than the previous one. The greedy approach scans left to right, adjusting each element to be exactly previous + 1 when needed. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force Recursive

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

For each position, try all possible increments from 0 to maximum needed, recursively solving for remaining positions. This explores the entire solution space.

Greedy Single Pass

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

Iterate through the array from left to right. For each element, if it's not greater than the previous element, increment it to be exactly one more than the previous element. This ensures strict increasing order with minimum operations.

Brute Force Recursive — Algorithm Steps

Try incrementing current element by 0, 1, 2, ... units
For each increment, recursively solve remaining array
Return minimum operations across all possibilities

Visualization

Tap to expand

Step-by-Step Walkthrough

Try Increments

For each position, try different increment amounts

Recurse

Recursively solve for remaining positions

Find Minimum

Return the minimum operations across all combinations

Code -

solution.c — C

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

static int nums_global[1000];
static int size_global;
static int current_array[1000];

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

int backtrack(int index) {
    if (index == size_global) {
        return 0;
    }
    
    int minOps = INT_MAX;
    
    int requiredMin = 0;
    if (index > 0) {
        requiredMin = current_array[index - 1] + 1;
    }
    
    int maxIncrement = 1000;
    if (index < size_global - 1) {
        maxIncrement = 100;
    }
    
    int startIncrement = 0;
    if (requiredMin > current_array[index]) {
        startIncrement = requiredMin - current_array[index];
    }
    
    for (int increment = startIncrement; increment <= maxIncrement; increment++) {
        int newValue = current_array[index] + increment;
        
        if (index == 0 || newValue > current_array[index - 1]) {
            int originalValue = current_array[index];
            current_array[index] = newValue;
            
            int remainingOps = backtrack(index + 1);
            
            if (remainingOps != INT_MAX) {
                int totalOps = increment + remainingOps;
                minOps = min_int(minOps, totalOps);
            }
            
            current_array[index] = originalValue;
        }
        
        if (minOps != INT_MAX && increment > startIncrement + 10) {
            break;
        }
    }
    
    return minOps;
}

int solution(int* nums, int size) {
    size_global = size;
    
    for (int i = 0; i < size; i++) {
        nums_global[i] = nums[i];
        current_array[i] = nums[i];
    }
    
    return backtrack(0);
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        if (*p == '-' || (*p >= '0' && *p <= '9')) {
            arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
        } else {
            p++;
        }
    }
}

int main() {
    char line[10000];
    if (fgets(line, sizeof(line), stdin) == NULL) {
        return 1;
    }
    
    line[strcspn(line, "\n")] = 0;
    
    static int nums[1000];
    int size = 0;
    
    parseArray(line, nums, &size);
    
    int result = solution(nums, size);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k^n)

For each position, we try k possible increments, and we have n positions

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth is n in the worst case

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~15 min Avg. Time

892 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 Recursive — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler