> For the complete documentation index, see [llms.txt](https://mayanktyagi3111.gitbook.io/interview-prep/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://mayanktyagi3111.gitbook.io/interview-prep/dynamic-programming/number-of-submatrices-that-sum-to-target.md).

# Number of Submatrices That Sum to Target

Given a `matrix`, and a `target`, return the number of non-empty submatrices that sum to target.

A submatrix `x1, y1, x2, y2` is the set of all cells `matrix[x][y]` with `x1 <= x <= x2` and `y1 <= y <= y2`.

Two submatrices `(x1, y1, x2, y2)` and `(x1', y1', x2', y2')` are different if they have some coordinate that is different: for example, if `x1 != x1'`.

**Example 1:**

```
Input: matrix = [[0,1,0],[1,1,1],[0,1,0]], target = 0
Output: 4
Explanation: The four 1x1 submatrices that only contain 0.
```

**Example 2:**

```
Input: matrix = [[1,-1],[-1,1]], target = 0
Output: 5
Explanation: The two 1x2 submatrices, plus the two 2x1 submatrices, plus the 2x2 submatrix.
```

**Note:**

1. `1 <= matrix.length <= 300`
2. `1 <= matrix[0].length <= 300`
3. `-1000 <= matrix[i] <= 1000`
4. `-10^8 <= target <= 10^8`

```java
public class Solution {
    public int helper(int[] sums, int target) {
        int sum = 0, ans = 0;
        HashMap<Integer, Integer> map = new HashMap<>();
        map.put(0, 1);
        for (int x : sums) {
            sum += x;
            ans += map.getOrDefault(sum - target, 0);
            map.put(sum, map.getOrDefault(sum, 0) + 1);
        }
        return ans;
    }

    public int numSubmatrixSumTarget(int[][] A, int target) {
        if (A.length == 0)
            return 0;
        int ans = 0;
        // Take 2 pointers
        for (int i = 0; i < A[0].length; i++) {
            int sum[] = new int[A.length];
            for (int j = i; j < A[0].length; j++) {
                // Find the prefix sum array of columns between these 2 pointers
                for (int k = 0; k < A.length; k++)
                    sum[k] += A[k][j];
                // Find subarays with sum == target
                ans += helper(sum, target);
            }
        }
        return ans;
    }
}
```