Maximum sum rectangle in a 2D matrix | DP-27

Last Updated : 17 Mar, 2025

Given a 2D array, the task is to find the maximum sum sub-matrix in it.

Example:

Input: mat=[[1,2,-1,-4,-20],[-8,-3,4,2,1],[3,8,10,1,3],[-4,-1,1,7,-6]]
Output: 29
Explanation: The matrix is as follows and the green rectangle denotes the maximum sum rectangle which is equal to 29.

This problem is mainly an extension of the findLargest Sum Contiguous Subarray for 1D array.

Table of Content

[Naive approach] Iterating Over All Possible Submatrices - O((n*m) ^ 3) Time and O(1) Space

We explore all possible rectangles in the given 2D array, by using four variables: two to define the left and right boundaries and two more to define the top and bottom boundaries and calculate their sums, and keep track of the maximum sum found.

C++

#include <bits/stdc++.h> using namespace std;  int maxSumRectangle(vector<vector<int>> &mat) {        int n = mat.size();     int m = mat[0].size();     int maxSum = INT_MIN;      for (int up = 0; up < n; up++) {         for (int left = 0; left < m; left++) {             for (int down = up; down < n; down++) {                 for (int right = left; right < m; right++) {                                          // Find the sum of submatrix(up, right, down, left)                     int sum = 0;                     for (int i = up; i <= down; i++) {                         for (int j = left; j <= right; j++) {                             sum += mat[i][j];                         }                     }                      // Update maxSum if sum > maxSum.                     if (sum > maxSum) {                         maxSum = sum;                     }                 }             }         }     }      return maxSum; } int main() {     vector<vector<int>> mat = {{1, 2, -1, -4, -20},                                 {-8, -3, 4, 2, 1},                                 {3, 8, 10, 1, 3},                                 {-4, -1, 1, 7, -6}};                                     cout <<maxSumRectangle(mat) << endl;     return 0; }

Java

import java.util.*;  class GfG {      static int maxSumRectangle(int[][] mat) {         int n = mat.length;         int m = mat[0].length;         int maxSum = Integer.MIN_VALUE;          for (int up = 0; up < n; up++) {             for (int left = 0; left < m; left++) {                 for (int down = up; down < n; down++) {                     for (int right = left; right < m; right++) {                                                // Find the sum of                         // submatrix(up, right, down, left)                         int sum = 0;                         for (int i = up;                              i <= down; i++) {                             for (int j = left;                                  j <= right; j++) {                                 sum += mat[i][j];                             }                         }                          // Update maxSum if sum > maxSum.                         if (sum > maxSum) {                             maxSum = sum;                         }                     }                 }             }         }          return maxSum;     }      public static void main(String[] args) {         int[][] mat = { { 1, 2, -1, -4, -20 },                         { -8, -3, 4, 2, 1 },                         { 3, 8, 10, 1, 3 },                         { -4, -1, 1, 7, -6 } };          System.out.println(maxSumRectangle(mat));     } }

Python

def maxSumRectangle(mat):     n = len(mat)     m = len(mat[0])     maxSum = float('-inf')      for up in range(n):         for left in range(m):             for down in range(up, n):                 for right in range(left, m):                                          # Calculate the sum of submatrix                      # (up, left, down, right)                     subMatrixSum = 0                     for i in range(up, down + 1):                         for j in range(left, right + 1):                             subMatrixSum += mat[i][j]                      # Update maxSum if a larger sum is found                     maxSum = max(maxSum, subMatrixSum)      return maxSum   if __name__ == "__main__":     mat = [         [1, 2, -1, -4, -20],         [-8, -3, 4, 2, 1],         [3, 8, 10, 1, 3],         [-4, -1, 1, 7, -6]     ]      print(maxSumRectangle(mat))

using System;  class GfG {     static int maxSumRectangle(int[][] mat) {         int n = mat.Length;         int m = mat[0].Length;         int maxSum = int.MinValue;          for (int up = 0; up < n; up++) {             for (int left = 0; left < m; left++) {                 for (int down = up; down < n; down++) {                     for (int right = left; right < m; right++) {                                                // Calculate the sum of submatrix                          // (up, left, down, right)                         int subMatrixSum = 0;                         for (int i = up; i <= down; i++) {                             for (int j = left; j <= right; j++) {                                 subMatrixSum += mat[i][j];                             }                         }                          // Update maxSum if a larger sum is found                         maxSum = Math.Max(maxSum, subMatrixSum);                     }                 }             }         }          return maxSum;     }      static void Main(string[] args) {         int[][] mat = {              new int[] { 1, 2, -1, -4, -20 },             new int[] { -8, -3, 4, 2, 1 },             new int[] { 3, 8, 10, 1, 3 },             new int[] { -4, -1, 1, 7, -6 }          };          Console.WriteLine(maxSumRectangle(mat));        } }

JavaScript

// JavaScript program Maximum sum rectangle in a 2D matrix.  function maxSumRectangle(mat) {     const n = mat.length;     const m = mat[0].length;     let maxSum = -Infinity;      for (let up = 0; up < n; up++) {         for (let left = 0; left < m; left++) {             for (let down = up; down < n; down++) {                 for (let right = left; right < m; right++) {                                      // Calculate the sum of submatrix                      // (up, left, down, right)                     let subMatrixSum = 0;                     for (let i = up; i <= down; i++) {                         for (let j = left; j <= right; j++) {                             subMatrixSum += mat[i][j];                         }                     }                      // Update maxSum if a larger sum is                     // found                     maxSum = Math.max(maxSum, subMatrixSum);                 }             }         }     }      return maxSum; }  const mat = [     [ 1, 2, -1, -4, -20 ],      [ -8, -3, 4, 2, 1 ],     [ 3, 8, 10, 1, 3 ],      [ -4, -1, 1, 7, -6 ] ];  console.log(maxSumRectangle(mat));

Time Complexity: O((n*m) ^ 3), as we iterate over all the boundaries of the rectangle in O((n*m) ^ 2) time. For each rectangle, we find its sum in O(n*m) time. Hence, overall time complexity will be O((n*m) ^ 2 * (n*m)) = O((n*m) ^ 3). where n is number of rows of the matrix and m is number of columns of the matrix.
Space Complexity: O(1), Constant space is used.

[Better Approach] Using Prefix Sum - O((nm)^2) Time and O(nm) Space

In this approach, we utilize the prefix sum matrix to efficiently calculate the sum of sub-matrices. here we precompute the prefix sum matrix.
The prefix sum matrix, pref[i][j], represents the sum of the sub-matrix with the top-left corner at (0, 0) and the bottom-right corner at (i, j). This allows us to quickly derive the sum of any sub-matrix using precomputed values, significantly reducing redundant calculations.

C++

#include <bits/stdc++.h> using namespace std;  int findSum(int r1, int c1, int r2, int c2,              	vector<vector<int>> &pref) {        // Start with the sum of the entire submatrix (0, 0) to (r2, c2)     int sum = pref[r2][c2]; 	   	// Subtract the area to the left of the submatrix, if it exists     if (c1 - 1 >= 0) {         sum -= pref[r2][c1 - 1];     }    	// Subtract the area above the submatrix, if it exists     if (r1 - 1 >= 0) {         sum -= pref[r1 - 1][c2];     }      // Add back the overlapping area that was subtracted twice     if (r1 - 1 >= 0 && c1 - 1 >= 0) {         sum += pref[r1 - 1][c1 - 1];     }      return sum; } int maxSumRectangle(vector<vector<int>> &mat) {     int n = mat.size();     int m = mat[0].size();      // Initialize the prefix sum matrix     vector<vector<int>> pref(n, vector<int>(m, 0));      // Row-wise sum     for (int i = 0; i < n; i++) {         for (int j = 0; j < m; j++) {             pref[i][j] = mat[i][j];             if (j - 1 >= 0) {                 pref[i][j] += pref[i][j - 1];             }         }     }      // Column-wise sum     for (int j = 0; j < m; j++) {         for (int i = 0; i < n; i++) {             if (i - 1 >= 0) {                 pref[i][j] += pref[i - 1][j];             }         }     }      int maxSum = INT_MIN;      for (int up = 0; up < n; up++) {         for (int left = 0; left < m; left++) {             for (int down = up; down < n; down++) {                 for (int right = left; right < m; right++) {                     // Find the sum of submatrix(up, right, down, left)                      int sum = findSum(up, left, down, right, pref);                      // Update maxSum if sum > maxSum.                     if (sum > maxSum) {                         maxSum = sum;                     }                 }             }         }     }      return maxSum; }  int main() {     vector<vector<int>> mat = {{1, 2, -1, -4, -20},                                 {-8, -3, 4, 2, 1},                                 {3, 8, 10, 1, 3},                                 {-4, -1, 1, 7, -6}};     cout << maxSumRectangle(mat) << endl; }

Java

import java.util.*;  class GfG {       static int findSum(int r1, int c1, int r2, int c2,                       int[][] pref) {         // Start with the sum of the entire submatrix          // (0, 0) to (r2, c2)         int sum = pref[r2][c2];        	// Subtract the area to the left of the submatrix,       	// if it exists         if (c1 - 1 >= 0) {             sum -= pref[r2][c1 - 1];         }        		// Subtract the area to the above the submatrix,        	// if it exists         if (r1 - 1 >= 0) {             sum -= pref[r1 - 1][c2];         }          	// Add back the overlapping area that was        	// subtracted twice         if (r1 - 1 >= 0 && c1 - 1 >= 0) {             sum += pref[r1 - 1][c1 - 1];         }          return sum;     }      // Function to find the maximum sum rectangle in a 2D     // matrix     public static int maxSumRectangle(int[][] mat) {         int n = mat.length;         int m = mat[0].length;          // Initialize the prefix sum matrix         int[][] pref = new int[n][m];          // Row-wise sum         for (int i = 0; i < n; i++) {             for (int j = 0; j < m; j++) {                 pref[i][j] = mat[i][j];                 if (j - 1 >= 0) {                     pref[i][j] += pref[i][j - 1];                 }             }         }          // Column-wise sum         for (int j = 0; j < m; j++) {             for (int i = 0; i < n; i++) {                 if (i - 1 >= 0) {                     pref[i][j] += pref[i - 1][j];                 }             }         }          // Find the maximum sum rectangle         int maxSum = Integer.MIN_VALUE;          for (int up = 0; up < n; up++) {             for (int left = 0; left < m; left++) {                 for (int down = up; down < n; down++) {                     for (int right = left; right < m;                          					right++) {                         // Find the sum of the submatrix                         // (up, left) to                         // (down, right)                         int sum = findSum( up, left, down,                                            	right, pref);                          // Update maxSum if sum > maxSum                         if (sum > maxSum) {                             maxSum = sum;                         }                     }                 }             }         }          return maxSum;     }      public static void main(String[] args) {         int[][] mat = { { 1, 2, -1, -4, -20 },                         { -8, -3, 4, 2, 1 },                         { 3, 8, 10, 1, 3 },                         { -4, -1, 1, 7, -6 } };          System.out.println(maxSumRectangle(mat));     } }

Python

def findSum(r1, c1, r2, c2, pref):        # Start with the sum of the entire submatrix      # (0, 0) to (r2, c2)     totalSum = pref[r2][c2]      # Subtract the area to the left of the submatrix,      # if it exists     if c1 - 1 >= 0:         totalSum -= pref[r2][c1 - 1]      # Subtract the area to the above the submatrix,      # if it exists     if r1 - 1 >= 0:         totalSum -= pref[r1 - 1][c2]         	# Add back the overlapping area that was subtracted twice     if r1 - 1 >= 0 and c1 - 1 >= 0:         totalSum += pref[r1 - 1][c1 - 1]      return totalSum   def maxSumRectangle(mat):     n = len(mat)     m = len(mat[0])      # Initialize the prefix sum matrix     pref = [[0] * m for _ in range(n)]      # Row-wise sum     for i in range(n):         for j in range(m):             pref[i][j] = mat[i][j]             if j - 1 >= 0:                 pref[i][j] += pref[i][j - 1] 	     # Column-wise sum     for j in range(m):         for i in range(n):             if i - 1 >= 0:                 pref[i][j] += pref[i - 1][j] 	     # Find the maximum sum rectangle     maxSum = float('-inf') 	     for up in range(n):         for left in range(m):             for down in range(up, n):                 for right in range(left, m):                     # Find the sum of the submatrix                      # (up, left) to (down, right)                     totalSum = findSum(                         up, left, down, right, pref)                      # Update maxSum if totalSum > maxSum                     if totalSum > maxSum:                         maxSum = totalSum      return maxSum  if __name__ == "__main__":     mat = [         [1, 2, -1, -4, -20],         [-8, -3, 4, 2, 1],         [3, 8, 10, 1, 3],         [-4, -1, 1, 7, -6]     ]      print(maxSumRectangle(mat))

using System;  class GfG {      static int findSum(int r1, int c1, int r2, int c2,                        int[, ] pref) {          // Start with the sum of the entire submatrix         // (0, 0) to (r2, c2)         int totalSum = pref[r2, c2];          // Subtract the area to the left of the submatrix,         // if it exists         if (c1 - 1 >= 0) {             totalSum -= pref[r2, c1 - 1];         }          // Subtract the area to the above the submatrix,         // if it exists         if (r1 - 1 >= 0) {             totalSum -= pref[r1 - 1, c2];         }          // Add back the overlapping area         // that was subtracted twice         if (r1 - 1 >= 0 && c1 - 1 >= 0) {             totalSum += pref[r1 - 1, c1 - 1];         }          return totalSum;     }      static int maxSumRectangle(int[, ] mat) {         int n = mat.GetLength(0);         int m = mat.GetLength(1);          // Initialize the prefix sum matrix         int[, ] pref = new int[n, m];          // Row-wise sum         for (int i = 0; i < n; i++) {             for (int j = 0; j < m; j++) {                 pref[i, j] = mat[i, j];                 if (j - 1 >= 0) {                     pref[i, j] += pref[i, j - 1];                 }             }         }          // Column-wise sum         for (int j = 0; j < m; j++) {             for (int i = 0; i < n; i++) {                 if (i - 1 >= 0) {                     pref[i, j] += pref[i - 1, j];                 }             }         }          // Find the maximum sum rectangle         int maxSum = int.MinValue;          for (int up = 0; up < n; up++) {             for (int left = 0; left < m; left++) {                 for (int down = up; down < n; down++) {                     for (int right = left; right < m;                          right++) {                                                // Find the sum of the submatrix                         // (up, left) to                         // (down, right)                         int totalSum = findSum(up, left,                                        down, right, pref);                          // Update maxSum if totalSum >                         // maxSum                         if (totalSum > maxSum) {                             maxSum = totalSum;                         }                     }                 }             }         }          return maxSum;     }      static void Main(string[] args) {         int[, ] mat = new int[, ] { { 1, 2, -1, -4, -20 },                                     { -8, -3, 4, 2, 1 },                                     { 3, 8, 10, 1, 3 },                                     { -4, -1, 1, 7, -6 } };          Console.Write(maxSumRectangle(mat));     } }

JavaScript

function findSum(r1, c1, r2, c2, pref) {      // Start with the sum of the entire submatrix (0, 0) to     // (r2, c2)     let sum = pref[r2][c2];      // Subtract the area to the left of the submatrix, if it     // exists     if (c1 - 1 >= 0) {         sum -= pref[r2][c1 - 1];     }          // Subtract the area to the above the submatrix, if it     // exists     if (r1 - 1 >= 0) {         sum -= pref[r1 - 1][c2];     }          // Add back the overlapping area that was subtracted     // twice     if (r1 - 1 >= 0 && c1 - 1 >= 0) {         sum += pref[r1 - 1][c1 - 1];     }      return sum; }  function maxSumRectangle(mat) {     const n = mat.length;     const m = mat[0].length;      // Initialize the prefix sum matrix     const pref         = Array.from({length : n}, () => Array(m).fill(0));      // Row-wise sum     for (let i = 0; i < n; i++) {         for (let j = 0; j < m; j++) {             pref[i][j] = mat[i][j];             if (j - 1 >= 0) {                 pref[i][j] += pref[i][j - 1];             }         }     }      // Column-wise sum     for (let j = 0; j < m; j++) {         for (let i = 0; i < n; i++) {             if (i - 1 >= 0) {                 pref[i][j] += pref[i - 1][j];             }         }     }      let maxSum = -Infinity;      for (let up = 0; up < n; up++) {         for (let left = 0; left < m; left++) {             for (let down = up; down < n; down++) {                 for (let right = left; right < m; right++) {                                      // Find the sum of the submatrix                     // (up, left) to                     // (down, right)                     let sum = findSum(up, left, down, right,                                       pref);                      // Update maxSum if sum > maxSum                     if (sum > maxSum) {                         maxSum = sum;                     }                 }             }         }     }      return maxSum; }  const mat = [     [ 1, 2, -1, -4, -20 ], [ -8, -3, 4, 2, 1 ],     [ 3, 8, 10, 1, 3 ], [ -4, -1, 1, 7, -6 ] ];  console.log(maxSumRectangle(mat));

Time Complexity: O((n*m)^2), due to iteration over all the boundaries of the rectangle in O((n*m) ^ 2), where n is the number of rows and m is the number of columns in the matrix.
Space Complexity: O(n*m) due to the prefix sum matrix.

[Expected Approach] Using Kadane’s Algorithm - O(nmm) Time and O(n) Space

We can optimize the above approach by using Kadane’s Algorithm, which efficiently finds the maximum subarray sum in a 1-D array.
The idea is to fix the left and right boundaries for a sub matrix, and then compute the sum of elements between these boundaries. Instead of recalculating the sum for every sub-matrix, we use an auxiliary array temp[] of size n to store the cumulative sums for each column within the current left and right boundaries. Once we have this 1-D representation of the matrix between the left and right boundaries, we can apply Kadane’s Algorithm to temp[] to find the maximum sum of a subarray, which corresponds to the maximum sum of the sub matrix.

C++

// C++ program Maximum sum rectangle in a 2D matrix.  #include <bits/stdc++.h> using namespace std;  // Kadane's algorithm to find the maximum sum  // subarray in a 1D array int kadaneAlgorithm(vector<int>& temp) {   	int rows = temp.size();     int currSum = 0;     int maxSum = INT_MIN;      for (int i = 0; i < rows; i++) {         currSum += temp[i];          // Update maxSum if the current sum is greater         if (maxSum < currSum) {             maxSum = currSum;         }          // If the current sum becomes negative, reset it to 0         if (currSum < 0) {             currSum = 0;         }     }      return maxSum; }  // Function to find the maximum sum rectangle in a 2D matrix int maxSumRectangle(vector<vector<int>> &mat) {     int rows = mat.size();     int cols = mat[0].size();      int maxSum = INT_MIN;      // Initialize a temporary array to store row-wise   	// sums between left and right boundaries     vector<int> temp(rows);      // Check for all possible left and right boundaries     for (int left = 0; left < cols; left++) {                // Reset the temporary array for each new left boundary         for (int i = 0; i < rows; i++)             temp[i] = 0;          for (int right = left; right < cols; right++) {                        // Update the temporary array with the current           	// column's values             for (int row = 0; row < rows; row++) {                 temp[row] += mat[row][right];             }              // Find the maximum sum of the subarray for the            	// current column boundaries             int sum = kadaneAlgorithm(temp);              // Update the maximum sum found so far             maxSum = max(maxSum, sum);         }     }      return maxSum; }  int main() {     vector<vector<int>> mat = {{1, 2, -1, -4, -20},                                {-8, -3, 4, 2, 1},                                 {3, 8, 10, 1, 3},                                {-4, -1, 1, 7, -6}};      int res = maxSumRectangle(mat);      cout << res << endl;                   return 0; }

Java

// Java program Maximum sum rectangle in a 2D matrix.  class GfG {      // Kadane's algorithm to find the maximum sum subarray     // in a 1D array     static int kadaneAlgorithm(int[] temp) {         int rows = temp.length;         int currSum = 0;         int maxSum = Integer.MIN_VALUE;          for (int i = 0; i < rows; i++) {             currSum += temp[i];              // Update maxSum if the current sum is greater             if (maxSum < currSum) {                 maxSum = currSum;             }              // If the current sum becomes negative, reset it             // to 0             if (currSum < 0) {                 currSum = 0;             }         }          return maxSum;     }      // Function to find the maximum sum rectangle in a 2D     // matrix     static int maxSumRectangle(int[][] mat) {         int rows = mat.length;         int cols = mat[0].length;          int maxSum = Integer.MIN_VALUE;          // Initialize a temporary array to store row-wise         // sums between left and right boundaries         int[] temp = new int[rows];          // Check for all possible left and right boundaries         for (int left = 0; left < cols; left++) {                        // Reset the temporary array for each new left             // boundary             for (int i = 0; i < rows; i++) {                 temp[i] = 0;             }              for (int right = left; right < cols; right++) {                                // Update the temporary array with the                 // current column's values                 for (int row = 0; row < rows; row++) {                     temp[row] += mat[row][right];                 }                  // Find the maximum sum of the subarray for                 // the current column boundaries                 int sum = kadaneAlgorithm(temp);                  // Update the maximum sum found so far                 maxSum = Math.max(maxSum, sum);             }         }          return maxSum;     }      public static void main(String[] args) {         int[][] mat = { { 1, 2, -1, -4, -20 },                         { -8, -3, 4, 2, 1 },                         { 3, 8, 10, 1, 3 },                         { -4, -1, 1, 7, -6 } };          int res = maxSumRectangle(mat);         System.out.println(res);     } }

Python

# Python program Maximum sum rectangle in a 2D matrix.  def kadaneAlgorithm(temp):     rows = len(temp)      currSum = 0     maxSum = float('-inf')      # Traverse the array     for i in range(rows):         currSum += temp[i]          # Update maxSum if the current sum is greater         if maxSum < currSum:             maxSum = currSum          # If the current sum becomes negative, reset it to 0         if currSum < 0:             currSum = 0      return maxSum   def maxSumRectangle(mat):     rows = len(mat)     cols = len(mat[0])      maxSum = float('-inf')      # Initialize a temporary array to store row-wise     # sums between left and right boundaries     temp = [0] * rows      # Check for all possible left and right boundaries     for left in range(cols):         # Reset the temporary array for each new left         # boundary         temp = [0] * rows          for right in range(left, cols):             # Update the temporary array with the current             # column's values             for row in range(rows):                 temp[row] += mat[row][right]              # Find the maximum sum of the subarray for the             # current column boundaries             sumValue = kadaneAlgorithm(temp)              # Update the maximum sum found so far             maxSum = max(maxSum, sumValue)      return maxSum  if __name__ == "__main__":     mat = [         [1, 2, -1, -4, -20],         [-8, -3, 4, 2, 1],         [3, 8, 10, 1, 3],         [-4, -1, 1, 7, -6]     ]      res = maxSumRectangle(mat)     print(res)

// C# program Maximum sum rectangle in a 2D matrix.  using System;  class GfG {        // Function to apply Kadane's algorithm to find the     // maximum sum subarray     static int kadaneAlgorithm(int[] temp) {         int rows = temp.Length;         int currSum = 0;         int maxSum = int.MinValue;          // Traverse the array         for (int i = 0; i < rows; i++) {             currSum += temp[i];              // Update maxSum if the current sum is greater             if (maxSum < currSum) {                 maxSum = currSum;             }              // If the current sum becomes negative, reset it             // to 0             if (currSum < 0) {                 currSum = 0;             }         }          return maxSum;     }      // Function to find the maximum sum of submatrix     static int maxSumRectangle(int[, ] mat) {         int rows = mat.GetLength(0);         int cols = mat.GetLength(1);          int maxSum = int.MinValue;          // Initialize a temporary array to store row-wise         // sums between left and right boundaries         int[] temp = new int[rows];          // Check for all possible left and right boundaries         for (int left = 0; left < cols; left++) {                        // Reset the temporary array for each new left             // boundary             Array.Clear(temp, 0, rows);              for (int right = left; right < cols; right++) {                                // Update the temporary array with the                 // current column's values                 for (int row = 0; row < rows; row++) {                     temp[row] += mat[row, right];                 }                  // Find the maximum sum of the subarray for                 // the current column boundaries                 int sumValue = kadaneAlgorithm(temp);                  // Update the maximum sum found so far                 maxSum = Math.Max(maxSum, sumValue);             }         }          return maxSum;     }      static void Main() {         int[, ] mat = { { 1, 2, -1, -4, -20 },                         { -8, -3, 4, 2, 1 },                         { 3, 8, 10, 1, 3 },                         { -4, -1, 1, 7, -6 } };          int res = maxSumRectangle(mat);         Console.WriteLine(res);     } }

JavaScript

// JavaScript program Maximum sum rectangle in a 2D matrix.  // Function to apply Kadane's algorithm to find the maximum // sum subarray function kadaneAlgorithm(temp) {     let rows = temp.length;     let currSum = 0;     let maxSum = -Infinity;      // Traverse the array     for (let i = 0; i < rows; i++) {         currSum += temp[i];          // Update maxSum if the current sum is greater         if (maxSum < currSum) {             maxSum = currSum;         }          // If the current sum becomes negative, reset it to         // 0         if (currSum < 0) {             currSum = 0;         }     }      return maxSum; }  // Function to find the maximum sum of submatrix function maxSumRectangle(mat) {     const rows = mat.length;     const cols = mat[0].length;      let maxSum = -Infinity;      // Initialize a temporary array to store row-wise sums     // between left and right boundaries     let temp = new Array(rows).fill(0);      // Check for all possible left and right boundaries     for (let left = 0; left < cols; left++) {              // Reset the temporary array for each new left         // boundary         temp.fill(0);          for (let right = left; right < cols; right++) {                      // Update the temporary array with the current             // column's values             for (let row = 0; row < rows; row++) {                 temp[row] += mat[row][right];             }              // Find the maximum sum of the subarray for the             // current column boundaries             let sumValue = kadaneAlgorithm(temp, rows);              // Update the maximum sum found so far             maxSum = Math.max(maxSum, sumValue);         }     }      return maxSum; }  // Driver Code const mat = [     [ 1, 2, -1, -4, -20 ],      [ -8, -3, 4, 2, 1 ],     [ 3, 8, 10, 1, 3 ],      [ -4, -1, 1, 7, -6 ] ];  const res = maxSumRectangle(mat); console.log(res);

Time complexity: O(n*m*m), where n is the number of rows and m is the number of columns in the matrix.
Space complexity: O(n)

Maximum sum rectangle in a 2D matrix | DP-27

kartik

Improve

Article Tags :

Practice Tags :

Maximum sum rectangle in a 2D matrix | DP-27

[Naive approach] Iterating Over All Possible Submatrices - O((n*m) ^ 3) Time and O(1) Space

[Better Approach] Using Prefix Sum - O((n*m)^2) Time and O(n*m) Space

[Expected Approach] Using Kadane’s Algorithm - O(n*m*m) Time and O(n) Space

Similar Reads

Advanced Topics

Easy problems in Dynamic programming

Medium problems on Dynamic programming

[Better Approach] Using Prefix Sum - O((nm)^2) Time and O(nm) Space

[Expected Approach] Using Kadane’s Algorithm - O(nmm) Time and O(n) Space