Leetcode--Java&Python--1277. 统计全为 1 的正方形子矩阵_java 在一个矩阵当中寻找完全为一的子矩阵-CSDN博客

本文链接：https://blog.csdn.net/Sherlock_Obama/article/details/119542780

这篇博客主要讲解如何使用动态规划解决LeetCode中的一个问题，即统计一个m*n矩阵中全为1的正方形子矩阵的数量。作者通过样例解释了问题，并给出了Java和Python两种语言的解决方案。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目描述

给你一个 m * n 的矩阵，矩阵中的元素不是 0 就是 1，请你统计并返回其中完全由 1 组成的正方形子矩阵的个数。

样例描述

示例 1：

输入：matrix =
[
  [0,1,1,1],
  [1,1,1,1],
  [0,1,1,1]
]
输出：15
解释： 
边长为 1 的正方形有 10 个。
边长为 2 的正方形有 4 个。
边长为 3 的正方形有 1 个。
正方形的总数 = 10 + 4 + 1 = 15.

思路

动态规划。本题的状态转化方程与下面这题一样，可以参考具体思路
Leetcode–Java–221. 最大正方形唯一区别就是状态表示含义不同，上题中表示的是最大边长，这题表示的是边长为f[i][j] = x的正方形，将所有边长为x（1,2，3…）的正方形累加起来就是总和。

代码

Java版：

class Solution {
    public int countSquares(int[][] matrix) {
         int m = matrix.length, n = matrix[0].length;
         if (matrix == null || m == 0 || n == 0) {
               return 0;
         }
          int f[][] = new int[m][n];
         int ans = 0;
         for (int i = 0; i < m; i ++ ) {
             for (int j = 0; j < n; j ++ ) {
                 //边界情况 直接赋值
                 if (i == 0 || j == 0) {
                     f[i][j] = matrix[i][j];
                 }
               //非边界
                else {
                  //如果是0，直接赋值为0
                  if (matrix[i][j] == 0) {
                      f[i][j] = 0;
                  }else {
        f[i][j] = Math.min(Math.min(f[i - 1][j], f[i][j - 1]), f[i - 1][j - 1]) + 1;
                  }
                }
                //所有边长为f[i][j]的正方形加起来    为0的话，等于没加不影响
                ans += f[i][j];
             }
         } 
         return ans;
      }
}

Python版：

class Solution:
    def countSquares(self, matrix: List[List[int]]) -> int:
        m, n = len(matrix), len(matrix[0])
        ans = 0
        if m == 0 or n == 0 or matrix == None:
            return ans
        dp = [[0] * n for _ in range(m)]
        for i in range(m):
            for j in range(n):
                if i == 0 or j == 0:
                    dp[i][j] = matrix[i][j]
                elif matrix[i][j] == 0:
                    dp[i][j] = 0
                else:
                    dp[i][j] = min(dp[i - 1][j], dp[i - 1][j - 1], dp[i][j - 1]) + 1
                ans += dp[i][j]
        return ans