Maximum Number of Moves in a Grid - Problem

Imagine you're a chess knight, but with special movement rules! You're given an m x n matrix filled with positive integers, and you can start at any cell in the first column.

Your goal is to traverse as far right as possible, but there's a catch: you can only move to cells with strictly larger values!

From any cell (row, col), you have three possible moves:

🔼 Up-right: (row-1, col+1)
➡️ Right: (row, col+1)
🔽 Down-right: (row+1, col+1)

Each move must be to a cell with a strictly greater value than your current position. Return the maximum number of moves you can make before getting stuck!

Input & Output

example_1.py — Basic Grid

$ Input: grid = [[2,4,3,5],[5,4,9,3],[3,4,2,11],[10,9,13,15]]

› Output: 3

💡 Note: Starting from (0,0) with value 2: move to (1,1) with value 4, then to (1,2) with value 9, then to (2,3) with value 11. Total moves: 3.

example_2.py — Single Row

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

› Output: 0

💡 Note: No matter which starting position we choose from the first column, we cannot make any valid moves because all adjacent cells in the next column have smaller or equal values.

example_3.py — Increasing Path

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

› Output: 3

💡 Note: Starting from any cell in the first column, we can move right through all columns since each column has strictly increasing values. Maximum moves = 3.

Constraints

m == grid.length
n == grid[i].length
2 ≤ m, n ≤ 1000
4 ≤ m * n ≤ 10⁵
1 ≤ grid[i][j] ≤ 10⁶

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 f Meta 6

The optimal approach uses dynamic programming to solve this problem efficiently. We process the grid from right to left, calculating the maximum moves possible from each position based on the results from the next column. The key insight is that we only need to consider three possible moves from each cell: up-right, right, and down-right, and we can only move to cells with strictly greater values. Time complexity: O(m × n), Space complexity: O(m × n).

Common Approaches

✓ Dynamic Programming (Bottom-Up)

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

Instead of using recursion, we can solve this iteratively by processing columns from right to left. For each cell, we calculate the maximum moves possible based on the results from the next column.

Dynamic Programming (Bottom-Up) — Algorithm Steps

Create a DP table where dp[i][j] represents max moves from position (i,j)
Initialize the last column: all cells have 0 moves (no more moves possible)
Process columns from right to left (second-to-last to first)
For each cell, calculate max moves by checking three possible next positions
The answer is the maximum value in the first column

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize last column

All cells in the last column have 0 moves (nowhere to go)

Process right to left

For each column, calculate max moves based on next column

Check valid moves

For each cell, check three possible moves to cells with greater values

Find maximum in first column

The answer is the maximum DP value in the first column

Code -

solution.c — C

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

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

int maxMoves(int** grid, int gridSize, int* gridColSize) {
    int m = gridSize, n = gridColSize[0];
    int** dp = (int**)malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        dp[i] = (int*)calloc(n, sizeof(int));
    }
    
    // Process columns from right to left
    for (int col = n - 2; col >= 0; col--) {
        for (int row = 0; row < m; row++) {
            int directions[3][2] = {{-1, 1}, {0, 1}, {1, 1}};
            
            for (int i = 0; i < 3; i++) {
                int newRow = row + directions[i][0];
                int newCol = col + directions[i][1];
                if (newRow >= 0 && newRow < m && newCol < n &&
                    grid[newRow][newCol] > grid[row][col]) {
                    dp[row][col] = max(dp[row][col], 1 + dp[newRow][newCol]);
                }
            }
        }
    }
    
    // Find maximum moves from first column
    int result = 0;
    for (int row = 0; row < m; row++) {
        result = max(result, dp[row][0]);
    }
    
    // Free memory
    for (int i = 0; i < m; i++) {
        free(dp[i]);
    }
    free(dp);
    
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int** grid = NULL;
    int* colSizes = NULL;
    int rows = 0;
    int maxRows = 100;
    
    grid = (int**)malloc(maxRows * sizeof(int*));
    colSizes = (int*)malloc(maxRows * sizeof(int));
    
    int i = 0;
    while (i < strlen(line)) {
        if (line[i] == '[' && i + 1 < strlen(line) && line[i + 1] != '[') {
            int* row = (int*)malloc(100 * sizeof(int));
            int cols = 0;
            i++; // skip '['
            
            char* endptr;
            while (i < strlen(line) && line[i] != ']') {
                if (line[i] >= '0' && line[i] <= '9') {
                    row[cols] = strtol(&line[i], &endptr, 10);
                    cols++;
                    i = endptr - line;
                } else {
                    i++;
                }
            }
            
            if (cols > 0) {
                grid[rows] = row;
                colSizes[rows] = cols;
                rows++;
            } else {
                free(row);
            }
        }
        i++;
    }
    
    printf("%d\n", maxMoves(grid, rows, colSizes));
    
    for (int i = 0; i < rows; i++) {
        free(grid[i]);
    }
    free(grid);
    free(colSizes);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n)

We visit each cell exactly once and do constant work per cell

✓ Linear Growth

Space Complexity

O(m × n)

DP table to store maximum moves for each position

⚡ Linearithmic Space

23.5K Views

Medium Frequency

~25 min Avg. Time

847 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

Maximum Number of Moves in a Grid - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Dynamic Programming (Bottom-Up) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler