[Coding Made Simple] Sum Query in 2D Immutable Array

Given a 2D immutable array,  Write an efficient program to support any given sub-rectangle sum query in this 2D matrix.

A simple solution is to add each entry inside the sub-rectangle. The runtime is O(n * m).

The problem of this solution is that for a given 2D matrix, we always start from scratch to compute the sum of a sub-rectangle.

Dynamic programming should be used to optimize the runtime.

State: T[i][j]: the sum of sub rectangle with top left corner (0, 0) and bottom right corner (i - 1, j - 1).

Function: T[i][j] = T[i - 1][j] + T[i][j - 1] + matrix[i - 1][j - 1] - T[i - 1][j - 1].

Initialization: T[0][j] = T[i][0] = 0; 

Answer:  given top left corner(x1, y1) and bottom right corner(x2, y2), 

　　　　Sum of sub rectangle(x1, y1, x2, y2) is T[x2 + 1][y2 + 1] - T[x1][y2 + 1] - T[x2 + 1][y1] + T[x1][y1].

public class SumQuery {
    private int[][] T;
    public SumQuery(int[][] matrix) {
        if(matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            T = null;
        }
        T = new int[matrix.length + 1][matrix[0].length + 1];
        for(int i = 0; i < T.length; i++) {
            T[i][0] = 0;
        }
        for(int j = 0; j < T[0].length; j++) {
            T[0][j] = 0;
        }
        for(int i = 1; i < T.length; i++) {
            for(int j = 1; j < T[0].length; j++) {
                T[i][j] = T[i - 1][j] + T[i][j - 1] + matrix[i - 1][j - 1] - T[i - 1][j - 1];
            }
        }
    }
    public int querySubRectangleSum(int x1, int y1, int x2, int y2) {
        x1++; y1++; x2++; y2++;
        return T[x2][y2] - T[x1 - 1][y2] - T[x2][y1 - 1] + T[x1 - 1][y1 - 1];
    }
}