Open In App

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

Last Updated : 17 Mar, 2025
Comments
Improve
Suggest changes
Like Article
Like
Report
Try it on GfG Practice
redirect icon

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.

maximum---------sum---------rectangle---------in---------a---------2d---------matrix---------3

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))
C# 
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((n*m)^2) Time and O(n*m) 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))
C# 
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(n*m*m) 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# 
// 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)


Next Article
Maximum sum rectangle in a 2D matrix | DP-27
author
kartik
Improve
Article Tags :
Practice Tags :

Similar Reads

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox