Maximum Difference Score in a Grid - Practice Coding Problems

Maximum Difference Score in a Grid - Problem

Grid Navigation Challenge: You're given an m × n matrix filled with positive integers. Your mission is to find the maximum score by making strategic moves through the grid.

Movement Rules:
• You can move from any cell to any other cell that is either below or to the right (not necessarily adjacent)
• You can start at any cell in the grid
• You must make at least one move

Scoring System:
The score for moving from cell with value c1 to cell with value c2 is c2 - c1

Goal: Return the maximum total score you can achieve across all possible paths.

Example: If you move from cell with value 5 to cell with value 8, you gain 3 points. If you then move to a cell with value 6, you lose 2 points, for a total score of 1.

Input & Output

example_1.py — Basic Grid

$ Input: grid = [[9,5,7,3], [8,9,6,1], [6,7,14,3], [2,5,3,1]]

› Output: 9

💡 Note: We can start at grid[3][0] = 2 and move to grid[2][2] = 14 for a score of 14 - 2 = 12. However, the optimal path is from grid[0][3] = 3 to grid[2][2] = 14 for a score of 14 - 3 = 11, but actually the best is from grid[3][0] = 2 to grid[1][0] = 8, then to grid[2][2] = 14. Wait, we can only make one move, so it's simply the maximum of (destination - source) for any valid pair. The maximum difference is 14 - 5 = 9.

example_2.py — Small Grid

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

› Output: -1

💡 Note: Since we can only move right or down, and all values are decreasing in those directions, the best we can do is lose as little as possible. The minimum loss is 1 (from 2 to 1), so the maximum score is -1.

example_3.py — Single Row

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

› Output: 8

💡 Note: We can move from the first cell (1) to the fourth cell (9) for a score of 9 - 1 = 8, which is the maximum possible.

Constraints

m == grid.length
n == grid[i].length
2 ≤ m, n ≤ 1000
4 ≤ m × n ≤ 10⁵
1 ≤ grid[i][j] ≤ 10⁵
You must make at least one move

Visualization

Tap to expand

Understanding the Visualization

Market Analysis

Scan through all available stock prices in chronological order

Track Best Buy Price

Keep track of the lowest price seen so far (best buying opportunity)

Calculate Profit

For each current price, calculate profit if we had bought at the best previous price

Maximize Returns

Keep track of the maximum profit possible across all opportunities

Key Takeaway

🎯 Key Insight: We don't need to check every possible pair. By maintaining the minimum value seen so far, we can calculate the optimal score for each position in a single pass!

Asked in

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

The optimal approach uses a single pass through the grid while tracking the minimum value seen so far. For each cell, we calculate the maximum possible score using that cell as destination and the best source encountered previously. This gives us O(mn) time complexity instead of the brute force O(m²n²).

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(mn)	O(1)	Track minimum value seen so far while scanning, calculate maximum difference on the fly
Brute Force (Try All Pairs)	O(m²n²)	O(1)	Check every possible pair of cells where second is below or right of first

Dynamic Programming (Optimal) — Algorithm Steps

Initialize minimum value seen so far and maximum score
Scan through the grid from top-left to bottom-right
For each cell, calculate potential score using current minimum as source
Update maximum score and minimum value as we progress

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with first cell as minimum

Scan Left-to-Right

Process each cell sequentially

Calculate Score

Use current cell - best minimum so far

Update Tracking

Update both max score and min value

Code -

solution.c — C

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

int maxScore(int** grid, int m, int n) {
    int maxScore = INT_MIN;
    int minVal = grid[0][0];
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (i == 0 && j == 0) continue;
            
            // Calculate score using best source so far
            int score = grid[i][j] - minVal;
            if (score > maxScore) {
                maxScore = score;
            }
            
            // Update minimum value seen
            if (grid[i][j] < minVal) {
                minVal = grid[i][j];
            }
        }
    }
    return maxScore;
}

int main() {
    int m, n;
    scanf("%d %d", &m, &n);
    
    int** grid = (int**)malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        grid[i] = (int*)malloc(n * sizeof(int));
        for (int j = 0; j < n; j++) {
            scanf("%d", &grid[i][j]);
        }
    }
    
    printf("%d\n", maxScore(grid, m, n));
    
    for (int i = 0; i < m; i++) {
        free(grid[i]);
    }
    free(grid);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(mn)

Single pass through the grid, constant work per cell

✓ Linear Growth

Space Complexity

O(1)

Only storing a few variables regardless of grid size

✓ Linear Space

23.4K Views

Medium Frequency

~18 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

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler