Maximum Difference Score in a Grid

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 need to find the maximum value of (destination - source) where we can move from source to destination (only right or down). The optimal move is from grid[0][1] = 5 to grid[2][2] = 14, giving us a score of 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

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

✓ Greedy

⏱️ Time: N/A Space: N/A

Brute Force (Try All Pairs)

⏱️ Time: O(m²n²) Space: O(1)

For each cell as a starting point, try moving to every possible destination cell (below or right) and calculate the score. Keep track of the maximum score found.

Dynamic Programming (Optimal)

⏱️ Time: O(mn) Space: O(1)

Instead of trying all pairs, we can solve this efficiently by maintaining the minimum value we've encountered so far as we scan through the grid. For each position, we calculate the maximum score possible by using that position as destination and the best source seen so far.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_SIZE 1000

int grid[MAX_SIZE][MAX_SIZE];

int maxScore(int m, int n) {
    int max_score = INT_MIN;
    
    // For each cell, find the minimum value that can reach it
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            int min_reachable = INT_MAX;
            // Check all cells that can reach (i,j)
            for (int x = 0; x <= i; x++) {
                for (int y = 0; y <= j; y++) {
                    if (x == i && y == j) {
                        continue;
                    }
                    if (grid[x][y] < min_reachable) {
                        min_reachable = grid[x][y];
                    }
                }
            }
            
            if (min_reachable != INT_MAX) {
                int score = grid[i][j] - min_reachable;
                if (score > max_score) {
                    max_score = score;
                }
            }
        }
    }
    
    return max_score;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse 2D array from JSON-like format
    int m = 0, n = 0;
    char* p = line;
    
    // Skip to first '['
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    // Parse rows
    while (*p && *p != ']') {
        if (*p == '[') {
            p++;
            n = 0;
            // Parse numbers in this row
            while (*p && *p != ']') {
                while (*p == ' ' || *p == ',') p++;
                if (*p == ']') break;
                grid[m][n++] = (int)strtol(p, &p, 10);
                while (*p == ' ' || *p == ',') p++;
            }
            if (*p == ']') p++;
            m++;
        } else {
            p++;
        }
    }
    
    printf("%d\n", maxScore(m, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ 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