Minimalist Forum Reader
Python:
class Solution:
    def countSubmatrices(self, grid: List[List[int]], k: int) -> int:
        m, n = len(grid), len(grid[0])
        sg = [[0] * (n+1) for _ in range(m+1)]

        result = 0
        for i in range(1, m+1):
            for j in range(1, n+1):
                sg[i][j] = sg[i-1][j] + sg[i][j-1] - sg[i-1][j-1] + grid[i-1][j-1]
                if sg[i][j] <= k:
                    result += 1
        return result
C++:
class Solution {
public:
    int countSubmatrices(vector<vector<int>>& grid, int k) {
        int res = 0, m = grid.size(), n = grid[0].size();
        vector<int> pre(n);
        for (int i = 0; i < m; i++) {
            int sum = 0;
            for (int j = 0; j < n; j++) {
                sum += grid[i][j];
                pre[j] += sum;
                if (pre[j] <= k) res++;
            }
        }
        return res;
    }
};
thuaaaaa
C#:
public class Solution
{
    public int CountSubmatrices(int[][] grid, int k)
    {
        int n = grid.Length;
        int m = grid[0].Length;
        int rtn = 0;
        for(int i=0;i<n;i++)
            for(int j=0;j<m;j++)
            {
                if (i > 0)
                   grid[i][j] += grid[i - 1][j];
                if (j > 0)
                    grid[i][j] += grid[i][j - 1];
                if(i>0&&j>0)
                    grid[i][j] -= grid[i-1][j - 1];

                if (grid[i][j] <= k)
                    rtn++;
            }
        return rtn;
    }
}
bài này giống bài dp đợt trước
grid[x][y]+= grid[x -1][y] + grid[x][y - 1] - grid[x - 1][y - 1]
JavaScript:
function countSubmatrices(grid: number[][], k: number): number {
    if (grid[0][0] > k) return 0;
    const m = grid.length, n = grid[0].length;
    let res = 0;

    for (let i = 0; i < m; i++) {
        for (let j = 0; j < n; j++) {
            let previousCol = j === 0 ? 0 : grid[i][ j - 1];
            let previousRow = i === 0 ? 0 : grid[i - 1][j];
            let previousDiagonal = (i === 0 || j === 0) ? 0 : grid[i - 1][j - 1]
            grid[i][j]+= previousCol + previousRow - previousDiagonal;
            if (grid[i][j] <= k) res++
        }
    }
    return res;

    
};
Reactions: JakovichTimViec