[Coding Made Simple] Maximum Sum Rectangular Submatrix in Matrix

Given a 2D matrix of  integers, find maximum sum rectangle in this matrix.

 

Brute force solution of enumerating all possible submatrix then check their sum is too inefficient. 

 

Algorithm of using the Kadane's algorithm(Maximum Subarray)

1. Fix a left and right column range to get a submatrix, there are O(col * col) such submatrices to consider.

2. For each submatrix, use a 1D array to get its total sum in O(row) time(dynamic programming used to avoid starting each computation from scratch).

    Then apply the Kadane's algorithm to get the maximum subarray sum on this 1D array in O(row) time. Because this 1D array represents the total

　 sum of the current submatrix, the max subarray sum from this 1D array represents the max rectangular submatrix sum of the current submatrix.

 

O(col * col * row) runtime, O(row) space

import java.util.ArrayList;

class Point {
    int row, col;
    Point(int r, int c) {
        row = r;
        col = c;
    }
    void display() {
        System.out.println(this.row + ", " + this.col);
    }
}
public class MaxRectangleSum {
    private ArrayList<Point> maxRecCoordinates = null;
    public int getMaxRecSum(int[][] matrix) {
        if(matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return 0;
        }
        maxRecCoordinates = new ArrayList<Point>();
        int max = Integer.MIN_VALUE, x = 0, y = 0;
        boolean hasPositiveInt = false;
        
        //preprocess matrix for case of no positive integer present
        for(int i = 0; i < matrix.length; i++) {
            for(int j = 0; j < matrix[0].length; j++) {
                if(matrix[i][j] > 0) {
                    hasPositiveInt = true;
                    break;
                }
                else if(matrix[i][j] > max){
                    max = matrix[i][j];
                    x = i;
                    y = j;
                }
            }
        }
        if(!hasPositiveInt) {
            for(int i = 0; i < 2; i++) {
                maxRecCoordinates.add(new Point(x, y));
            }
            return max;
        }
        
        max = Integer.MIN_VALUE;
        int[] range= new int[2];
        int maxLeft = 0, maxRight = 0, maxTop = 0, maxBottom = 0;
        int[] colArr = new int[matrix.length];
        for(int l = 0; l < matrix[0].length; l++) {
            for(int i = 0; i < matrix.length; i++) {
                colArr[i] = 0;
            }
            for(int r = l; r < matrix[0].length; r++) {
                for(int i = 0; i < matrix.length; i++) {
                    colArr[i] += matrix[i][r]; 
                }
                int currSum = getMaxSubarraySum(colArr, range);
                if(currSum > max) {
                    max = currSum;
                    maxLeft = l;
                    maxRight = r;
                    maxTop = range[0];
                    maxBottom = range[1];
                }
            }
        }
        Point topLeft = new Point(maxTop, maxLeft);
        Point bottomRight = new Point(maxBottom, maxRight);
        maxRecCoordinates.add(topLeft);
        maxRecCoordinates.add(bottomRight);
        return max;
    }
    private int getMaxSubarraySum(int[] arr, int[] range) {
        range[0] = 0;
        range[1] = 0;
        int currSum = 0, minSum = 0, maxSum = Integer.MIN_VALUE;
        int minSumEndIdx = -1;
        for(int i = 0; i < arr.length; i++) {
            currSum += arr[i];
            if(currSum - minSum > maxSum) {
                maxSum = currSum - minSum;
                range[0] = minSumEndIdx + 1;
                range[1] = i;
            }
            if(currSum < minSum) {
                minSum = currSum;
                minSumEndIdx = i;
            }
        }
        return maxSum;
    }
    public static void main(String[] args) {
        int[][] matrix1 = {{2,1,-3,-4,5}, {0,6,3,4,1},{2,-2,-1,4,-5},{-3,3,1,0,3}};
        int[] arr = {-2,2,-3,4,-1,2,1,-5,3};
        int[] range = new int[2];
        MaxRectangleSum test = new MaxRectangleSum();
        System.out.println(test.getMaxSubarraySum(arr, range));
        for(int i = 0; i < 2; i++) {
            System.out.println(range[i]);
        }
        System.out.println(test.getMaxRecSum(matrix1));
        for(int i = 0; i < test.maxRecCoordinates.size(); i++) {
            test.maxRecCoordinates.get(i).display();
        }
    }
}

 

 

Related Problems 

[LintCode] Maximum Subarray

Submatrix Sum To Zero