Maximum Strictly Increasing Cells in a Matrix

Maximum Strictly Increasing Cells in a Matrix - Problem

Array Hash Table Binary Search Dynamic Programming Memoization Sorting Matrix Ordered Set Hard

Imagine you're a treasure hunter exploring a mysterious grid-based dungeon where each cell contains a magical number. You can start from any cell and move to other cells in the same row or column, but there's a catch: you can only move to cells with strictly greater values than your current position!

Given an m x n integer matrix, your goal is to find the maximum number of cells you can visit by choosing the optimal starting position and making the smartest moves possible.

Movement Rules:

Start from any cell in the matrix
Move only within the same row or column
Destination cell value must be strictly greater than current cell
Continue until no valid moves remain

Goal: Return the maximum number of cells that can be visited in a single journey.

Input & Output

example_1.py — Basic Matrix

$ Input: mat = [[3,1,6],[-9,5,7]]

› Output: 4

💡 Note: The optimal path is: -9 → 5 → 7 → 6. Start at (-9) in position (1,0), move to (5) in same row at (1,1), then move to (7) in same row at (1,2), finally move to (6) in same column at (0,2). This gives us a path of length 4.

example_2.py — Single Row

$ Input: mat = [[7,6,3]]

› Output: 1

💡 Note: Since all movements must be to strictly greater values, and this row is in decreasing order, we can only visit one cell. No matter which cell we start from, there are no valid moves to cells with greater values.

example_3.py — Perfect Increasing

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

› Output: 3

💡 Note: Multiple optimal paths exist: 1→2→4 or 1→3→4, both having length 3. We can start at (1) and move to either (2) or (3), then continue to (4) for a total of 3 cells visited.

Constraints

m == mat.length
n == mat[i].length
1 ≤ m, n ≤ 10⁵
1 ≤ m * n ≤ 10⁵
-10⁵ ≤ mat[i][j] ≤ 10⁵

Visualization

Tap to expand

Understanding the Visualization

Survey the Terrain

Look at the matrix and identify all possible starting positions and their neighboring cells with greater values.

Plan the Route

Start from the lowest values and work your way up, building optimal paths incrementally.

Track Progress

Use dynamic programming to remember the best path length achievable from each position.

Find the Peak

The maximum value in your DP table represents the longest possible journey.

Key Takeaway

🎯 Key Insight: Process cells in ascending order of values - this ensures optimal substructure and eliminates the need for complex memoization!

Asked in

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

The optimal solution uses dynamic programming with coordinate compression. By processing cells in ascending order of their values, we ensure that when computing the maximum path for any cell, all cells with smaller values already have their optimal paths computed. This eliminates redundant calculations and achieves O(m*n*log(m*n)) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Coordinate Compression (Optimal)	O(mnlog(m*n))	O(m*n)	Process cells in ascending order of values using coordinate compression and DP
Dynamic Programming with Memoization	O(mn(m+n))	O(m*n)	Use memoization to cache results and avoid recomputing paths

Dynamic Programming with Coordinate Compression (Optimal) — Algorithm Steps

Collect all unique values from the matrix and sort them
Group cells by their values and process in ascending order
For each value group, compute max path length using previously processed cells
Use coordinate compression to efficiently query max paths in rows/columns
Update row and column maximums after processing each value group
Return the overall maximum path length found

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Values

Group cells by value and process in ascending order

Process Group

For each value group, compute max path using row/column maximums

Update Maximums

Update row and column maximum arrays after processing each group

Find Result

The maximum value in DP table is our answer

Code -

solution.c — C

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

#define MAX_CELLS 10000

typedef struct {
    int value;
    int i, j;
} Cell;

int compare(const void* a, const void* b) {
    Cell* cellA = (Cell*)a;
    Cell* cellB = (Cell*)b;
    return cellA->value - cellB->value;
}

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

int maxIncreasingCells(int** mat, int m, int n) {
    Cell cells[MAX_CELLS];
    int cellCount = 0;
    
    // Collect all cells
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            cells[cellCount].value = mat[i][j];
            cells[cellCount].i = i;
            cells[cellCount].j = j;
            cellCount++;
        }
    }
    
    // Sort cells by value
    qsort(cells, cellCount, sizeof(Cell), compare);
    
    // DP arrays
    int dp[m][n];
    int rowMax[m], colMax[n];
    memset(dp, 0, sizeof(dp));
    memset(rowMax, 0, sizeof(rowMax));
    memset(colMax, 0, sizeof(colMax));
    
    // Process cells in ascending order
    int i = 0;
    while (i < cellCount) {
        int currentValue = cells[i].value;
        int start = i;
        
        // Find all cells with the same value
        while (i < cellCount && cells[i].value == currentValue) {
            i++;
        }
        
        // Calculate new DP values for this group
        int newDpValues[i - start];
        for (int k = start; k < i; k++) {
            int row = cells[k].i, col = cells[k].j;
            newDpValues[k - start] = max(rowMax[row], colMax[col]) + 1;
        }
        
        // Update DP table and maximums
        for (int k = start; k < i; k++) {
            int row = cells[k].i, col = cells[k].j;
            dp[row][col] = newDpValues[k - start];
            rowMax[row] = max(rowMax[row], dp[row][col]);
            colMax[col] = max(colMax[col], dp[row][col]);
        }
    }
    
    // Find maximum result
    int result = 0;
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            result = max(result, dp[i][j]);
        }
    }
    
    return result;
}

int main() {
    int* row1 = malloc(3 * sizeof(int));
    int* row2 = malloc(3 * sizeof(int));
    row1[0] = 3; row1[1] = 1; row1[2] = 6;
    row2[0] = -9; row2[1] = 5; row2[2] = 7;
    int** mat = malloc(2 * sizeof(int*));
    mat[0] = row1; mat[1] = row2;
    
    printf("%d\n", maxIncreasingCells(mat, 2, 3));
    
    free(row1); free(row2); free(mat);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m*n*log(m*n))

Sorting cells takes O(m*n*log(m*n)), then each cell is processed once with O(log(m*n)) operations

⚡ Linearithmic

Space Complexity

O(m*n)

Additional space for sorting, grouping cells, and storing row/column maximums

⚡ Linearithmic Space

34.3K Views

Medium-High Frequency

~25 min Avg. Time

1.5K 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 with Coordinate Compression (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler