Minimum Operations to Make Columns Strictly Increasing

Minimum Operations to Make Columns Strictly Increasing - Problem

Making Matrix Columns Strictly Increasing

You're given an m × n matrix grid filled with non-negative integers. Your task is to transform this matrix so that every column becomes strictly increasing from top to bottom.

In each operation, you can increment any cell grid[i][j] by exactly 1. The challenge is to find the minimum number of operations needed to achieve this goal.

What does "strictly increasing" mean?
For any column j, we need: grid[0][j] < grid[1][j] < grid[2][j] < ... < grid[m-1][j]

Goal: Return the minimum number of increment operations needed.
Constraint: You can only increase values, never decrease them.

Input & Output

example_1.py — Basic Example

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

› Output: 15

💡 Note: Column 1: [3,1,3,0] → [3,4,5,6] (operations: 3+2+6=11). Column 2: [2,3,4,1] → [2,3,4,5] (operations: 4). Total: 15 operations.

example_2.py — Already Increasing

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

› Output: 0

💡 Note: Both columns are already strictly increasing: [1,3,5] and [2,4,6]. No operations needed.

example_3.py — Single Column

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

› Output: 5

💡 Note: Column needs to become [2,3,4,5]. Operations: 1→4(+3), 0→5(+5). Total: 8 operations.

Constraints

1 ≤ m, n ≤ 1000
0 ≤ grid[i][j] ≤ 10⁹
You can only increment values, never decrease them

Visualization

Tap to expand

Understanding the Visualization

Identify Problem Areas

Mark buildings that are too short compared to their northern neighbors

Add Floors Greedily

For each problematic building, add exactly enough floors to be 1 taller than the previous

Process Street by Street

Handle each column independently - changes in one street don't affect others

Count Total Construction

Sum up all the floors added across all buildings

Key Takeaway

🎯 Key Insight: Greedy approach works perfectly - at each position, ensure it's exactly 1 greater than the previous element, minimizing total operations

Asked in

G Google 25 a Amazon 18 f Meta 12 ⊞ Microsoft 8

The optimal approach uses a greedy strategy to process each column independently. For each column, iterate from top to bottom and ensure each element is exactly previous + 1 when needed. This guarantees the minimum operations since we only increment by the required amount. Time complexity: O(m×n), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Column by Column)	O(m × n)	O(1)	Process each column independently, ensuring strict increasing order

Brute Force (Column by Column) — Algorithm Steps

Initialize operations counter to 0
For each column j from 0 to n-1:
For each row i from 1 to m-1 in current column:
If grid[i][j] <= grid[i-1][j], increment grid[i][j] to grid[i-1][j] + 1
Add the number of increments to operations counter
Return total operations

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with original matrix

Identify which elements need to be increased

Process first column

Make first column strictly increasing

Process remaining columns

Apply same logic to each column independently

Count total operations

Sum up all the increment operations needed

Code -

solution.c — C

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

int minOperations(int** grid, int gridSize, int* gridColSize) {
    if (gridSize == 0 || gridColSize[0] == 0) {
        return 0;
    }
    
    int m = gridSize;
    int n = gridColSize[0];
    int operations = 0;
    
    // Process each column
    for (int col = 0; col < n; col++) {
        // Process each row from second row onwards
        for (int row = 1; row < m; row++) {
            if (grid[row][col] <= grid[row-1][col]) {
                // Calculate operations needed
                int needed = grid[row-1][col] + 1 - grid[row][col];
                operations += needed;
                grid[row][col] = grid[row-1][col] + 1;
            }
        }
    }
    
    return operations;
}

int main() {
    // Example usage
    int* grid[4];
    int row0[] = {3, 2};
    int row1[] = {1, 3};
    int row2[] = {3, 4};
    int row3[] = {0, 1};
    grid[0] = row0; grid[1] = row1; grid[2] = row2; grid[3] = row3;
    
    int colSizes[] = {2, 2, 2, 2};
    printf("%d\n", minOperations(grid, 4, colSizes));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n)

We visit each cell exactly once, where m is rows and n is columns

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space (if we modify in-place)

✓ Linear Space

28.0K 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 (Column by Column) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler