Maximum Number of Moves in a Grid - Practice Coding Problems

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 (1,0) with value 5: move to (0,1) with value 4, then to (0,2) with value 9, then to (1,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

Understanding the Visualization

Choose starting point

Start at any base camp in the first valley (first column)

Plan the route

From each position, check three possible paths: up-right, right, down-right

Climb higher

Only move to positions with higher elevation (greater values)

Find longest path

Use dynamic programming to efficiently find the path with maximum steps

Key Takeaway

🎯 Key Insight: By using dynamic programming and processing from right to left, we can efficiently calculate the maximum moves from any starting position without redundant calculations.

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

Approach	Time	Space	Notes
✓ Dynamic Programming (Bottom-Up)	O(m × n)	O(m × n)	Build solution from right to left using dynamic programming

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>

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() {
    int rows = 4, cols = 4;
    int** grid = (int**)malloc(rows * sizeof(int*));
    int gridData[4][4] = {{2,4,3,5},{5,4,9,3},{3,4,2,11},{10,9,13,15}};
    int colSizes[] = {4,4,4,4};
    
    for (int i = 0; i < rows; i++) {
        grid[i] = gridData[i];
    }
    
    printf("%d\n", maxMoves(grid, rows, colSizes));
    free(grid);
    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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Dynamic Programming (Bottom-Up) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler