Max Diff with Below and Right in Grid

Given a square matrix mat[][] of size n * n, select two elements such that the second element lies strictly below and strictly to the right of the first element.
Return the maximum possible difference between these two elements.
In other words, for any two elements mat[a][b] and mat[c][d], find the maximum value of mat[c][d] - mat[a][b] such that c > a and d > b.

Examples:

Input: mat = [[1, 2, -1, -4, -20], [-8, -3, 4, 2, 1], [3, 8, 6, 1, 3], [-4, -1, 1, 7, -6], [0, -4, 10, -5, 1]]
Output: 18
Explanation: Choose -8 at position (1, 0) and 10 at position (4, 2). Since the second element is strictly below and strictly to the right of the first element, 10 - (-8) = 18, which is the maximum possible difference.
Input: mat = [[5, 4], [3, 2]]
Output: -3
Explanation: The only valid pair is 5 and 2. 2 - 5 = -3. Hence, the maximum possible difference is -3.

Try It Yourself

Table of Content

[Naive Approach] Try Every Pair - O(n^4) Time and O(1) Space
[Expected Approach] Suffix Maximum (Space Optimized) - O(n^2) Time and O(n) Space

[Naive Approach] Try Every Pair - O(n^4) Time and O(1) Space

Every possible pair of positions (a, b) and (c, d) with c > a and d > b can be checked directly, computing mat[c][d] - mat[a][b] for each and tracking the maximum found. Since this involves iterating over every possible first position and then every possible second position that lies strictly below and to the right, the total work grows with the fourth power of the matrix dimension, which becomes very slow for large matrices.

Illustration:

Take mat = [[5, 4], [3, 2]].
The only position that has anything strictly below and to the right of it is (0, 0), with value 5.
The only valid second position is (1, 1), with value 2.
Computing 2 - 5 gives -3, which is checked against all other pairs, but since no other valid pair exists in this 2x2 matrix, -3 is the final answer.

C++

#include <bits/stdc++.h>
using namespace std;

int findMaxValue(vector<vector<int>>& mat) {
    int n = mat.size();
    int res = INT_MIN;

    // try every valid pair of positions directly
    for (int a = 0; a < n; a++) {
        for (int b = 0; b < n; b++) {
            for (int c = a + 1; c < n; c++) {
                for (int d = b + 1; d < n; d++) {
                    res = max(res, mat[c][d] - mat[a][b]);
                }
            }
        }
    }

    return res;
}

int main() {
    vector<vector<int>> mat = {{5, 4}, {3, 2}};

    cout << findMaxValue(mat) << endl;

    return 0;
}

Java

class GfG {
    static int findMaxValue(int[][] mat) {
        int n = mat.length;
        int res = Integer.MIN_VALUE;

        // try every valid pair of positions directly
        for (int a = 0; a < n; a++) {
            for (int b = 0; b < n; b++) {
                for (int c = a + 1; c < n; c++) {
                    for (int d = b + 1; d < n; d++) {
                        res = Math.max(res, mat[c][d] - mat[a][b]);
                    }
                }
            }
        }

        return res;
    }

    public static void main(String[] args) {
        int[][] mat = {{5, 4}, {3, 2}};

        System.out.println(findMaxValue(mat));
    }
}

Python

def findMaxValue(mat):
    n = len(mat)
    res = float('-inf')

    # try every valid pair of positions directly
    for a in range(n):
        for b in range(n):
            for c in range(a + 1, n):
                for d in range(b + 1, n):
                    res = max(res, mat[c][d] - mat[a][b])

    return res

mat = [[5, 4], [3, 2]]
print(findMaxValue(mat))

using System;

class GfG {
    static int findMaxValue(int[][] mat) {
        int n = mat.Length;
        int res = int.MinValue;

        // try every valid pair of positions directly
        for (int a = 0; a < n; a++) {
            for (int b = 0; b < n; b++) {
                for (int c = a + 1; c < n; c++) {
                    for (int d = b + 1; d < n; d++) {
                        res = Math.Max(res, mat[c][d] - mat[a][b]);
                    }
                }
            }
        }

        return res;
    }

    static void Main() {
        int[][] mat = { new int[]{5, 4}, new int[]{3, 2} };

        Console.WriteLine(findMaxValue(mat));
    }
}

JavaScript

function findMaxValue(mat) {
    const n = mat.length;
    let res = -Infinity;

    // try every valid pair of positions directly
    for (let a = 0; a < n; a++) {
        for (let b = 0; b < n; b++) {
            for (let c = a + 1; c < n; c++) {
                for (let d = b + 1; d < n; d++) {
                    res = Math.max(res, mat[c][d] - mat[a][b]);
                }
            }
        }
    }

    return res;
}

// Driver Code
const mat = [[5, 4], [3, 2]];
console.log(findMaxValue(mat));

Output

-3

[Expected Approach] Suffix Maximum (Space Optimized) - O(n^2) Time and O(n) Space

For each position (a,b), the optimal second element is the maximum value strictly below and to the right. Compute these using suffix maxima from the bottom-right to the top-left, ensuring the required maximum is already available when processing a cell. Since each row depends only on the row below, only the current and next suffix-maximum rows need to be stored, reducing memory usage.