Minimum Operations to Make Columns Strictly Increasing

Minimum Operations to Make Columns Strictly Increasing - Problem

You are given a m x n matrix grid consisting of non-negative integers.

In one operation, you can increment the value of any grid[i][j] by 1.

Return the minimum number of operations needed to make all columns of grid strictly increasing.

A column is strictly increasing if each element is greater than the element above it: grid[i][j] < grid[i+1][j] for all valid i.

Input & Output

Example 1 — Basic Case

$ Input: grid = [[3,1,6],[1,1,9],[2,4,7]]

› Output: 10

💡 Note: Column 1: [3,1,2] → [3,4,5] (1→4 needs +3, 2→5 needs +3, total 6 ops), Column 2: [1,1,4] → [1,2,4] (1→2 needs +1 op), Column 3: [6,9,7] → [6,9,10] (7→10 needs +3 ops). Total: 10

Example 2 — Already Increasing

$ Input: grid = [[1,2],[3,4]]

› Output: 0

💡 Note: Both columns are already strictly increasing: [1,3] and [2,4], so no operations needed

Example 3 — Single Column

$ Input: grid = [[5],[4],[3]]

› Output: 6

💡 Note: Column [5,4,3] needs to become [5,6,7]: 4→6 (+2 ops), 3→7 (+4 ops). Total: 6 operations

Constraints

1 ≤ m, n ≤ 1000
0 ≤ grid[i][j] ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to process each column independently and make minimal increments. For each column, scan from top to bottom and ensure each element is exactly 1 greater than the element above it when needed. Best approach is greedy with optimal Time: O(m×n), Space: O(1).

Common Approaches

✓ Brute Force - Check All Columns

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

For each column, go from top to bottom and ensure each element is greater than the previous one. If not, increment it to be exactly one more than the previous element.

Greedy Approach

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

For each column, scan from top to bottom. When we find an element that's not greater than the previous one, increment it to be exactly previous + 1. This ensures minimal operations while maintaining strictly increasing property.

Brute Force - Check All Columns — Algorithm Steps

Iterate through each column
For each column, go from second row to last
If current element <= previous, increment it to previous + 1
Count total operations

Visualization

Tap to expand

Step-by-Step Walkthrough

Input Matrix

Original matrix with some non-increasing columns

Process Columns

Go through each column top to bottom

Count Operations

Total increments needed

Code -

solution.c — C

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

/* This is greedy */

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;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int solution(int** grid, int m, int n) {
    int operations = 0;
    
    // Process each column independently
    for (int col = 0; col < n; col++) {
        // Go from top to bottom in current column
        for (int row = 1; row < m; row++) {
            // If current cell is not greater than cell above
            if (grid[row][col] <= grid[row-1][col]) {
                // Calculate minimum value needed
                int required = grid[row-1][col] + 1;
                // Add operations needed
                operations += required - grid[row][col];
                // Update the cell value
                grid[row][col] = required;
            }
        }
    }
    
    return operations;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int** grid = malloc(100 * sizeof(int*));
    for (int i = 0; i < 100; i++) {
        grid[i] = malloc(100 * sizeof(int));
    }
    
    int m = 0, n = 0;
    char* ptr = line + 1;
    
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            n = 0;
            while (*ptr && *ptr != ']') {
                if (*ptr >= '0' && *ptr <= '9') {
                    int num = 0;
                    while (*ptr >= '0' && *ptr <= '9') {
                        num = num * 10 + (*ptr - '0');
                        ptr++;
                    }
                    grid[m][n++] = num;
                } else {
                    ptr++;
                }
            }
            if (*ptr == ']') ptr++;
            m++;
        } else {
            ptr++;
        }
    }
    
    int result = solution(grid, m, n);
    printf("%d\n", result);
    
    for (int i = 0; i < 100; i++) {
        free(grid[i]);
    }
    free(grid);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n)

Visit each cell once in the matrix

✓ Linear Growth

Space Complexity

O(1)

Only use constant extra space for counters

✓ Linear Space

12.5K Views

Medium Frequency

~15 min Avg. Time

425 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 - Check All Columns — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler