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

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

✓ Dynamic Programming with Coordinate Compression (Optimal)

⏱️ Time: O(m*n*log(m*n)) Space: O(m*n)

The optimal approach uses dynamic programming with coordinate compression. We sort all unique values and process cells in ascending order. For each cell, we find the maximum path length from all smaller-valued cells in the same row/column using efficient data structures. This ensures we only compute each cell once and in the correct order.

Dynamic Programming with Memoization

⏱️ Time: O(m*n*(m+n)) Space: O(m*n)

Enhance the DFS approach by adding memoization to store previously computed results. This prevents redundant calculations when exploring paths that lead to the same cells. We still try every cell as a starting point, but now we cache the maximum path length achievable from each cell.

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>
#include <ctype.h>

#define MAX_CELLS 10000
#define MAX_SIZE 1000

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

static Cell cells[MAX_CELLS];
static int dp[MAX_SIZE][MAX_SIZE];
static int rowMax[MAX_SIZE], colMax[MAX_SIZE];

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) {
    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);
    
    // Initialize arrays
    memset(dp, 0, sizeof(int) * m * n);
    memset(rowMax, 0, sizeof(rowMax));
    memset(colMax, 0, sizeof(colMax));
    
    int result = 0;
    
    // 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;
            int currMax = max(rowMax[row], colMax[col]) + 1;
            newDpValues[k - start] = currMax;
            result = max(result, currMax);
        }
        
        // Update DP table and row/column maximums after processing all cells with current value
        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]);
        }
    }
    
    return result;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    // Parse 2D array from string like "[[3,1,6],[-9,5,7]]"
    int mat[MAX_SIZE][MAX_SIZE];
    int* matPtrs[MAX_SIZE];
    int m = 0, n = 0;
    
    char* ptr = input;
    while (*ptr) {
        if (*ptr == '[' && (ptr == input || *(ptr-1) != '[')) {
            ptr++; // skip '['
            int j = 0;
            while (*ptr && *ptr != ']') {
                if (isdigit(*ptr) || *ptr == '-') {
                    char* end;
                    mat[m][j] = strtol(ptr, &end, 10);
                    ptr = end;
                    j++;
                } else {
                    ptr++;
                }
            }
            if (m == 0) n = j;
            matPtrs[m] = mat[m];
            m++;
        }
        if (*ptr) ptr++;
    }
    
    printf("%d\n", maxIncreasingCells(matPtrs, m, n));
    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