寻找最大的正方子矩阵

是一个常见的算法问题，可以通过动态规划来解决。

动态规划解决该问题的思路如下：

创建一个与原矩阵相同大小的辅助矩阵dp，用于记录以当前位置为右下角的最大正方形边长。
遍历原矩阵，对于每个位置(i, j)，如果该位置的值为1，则将dp[i][j]初始化为1，表示以该位置为右下角的最大正方形边长为1。
对于其他位置(i, j)，如果该位置的值为1，则将dp[i][j]的值更新为min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1]) + 1，表示以该位置为右下角的最大正方形边长为左边、上边和左上角三个位置的最小边长加1。
在更新dp的过程中，记录最大的正方形边长maxLen，以及对应的右下角位置(r, c)。
最终，最大的正方形边长即为maxLen，对应的正方形子矩阵为以位置(r, c)为右下角，边长为maxLen的正方形子矩阵。

以下是一个示例代码实现：

def findLargestSquareMatrix(matrix):
    rows = len(matrix)
    cols = len(matrix[0])
    dp = [[0] * cols for _ in range(rows)]
    maxLen = 0
    r, c = 0, 0

    for i in range(rows):
        for j in range(cols):
            if matrix[i][j] == 1:
                if i == 0 or j == 0:
                    dp[i][j] = 1
                else:
                    dp[i][j] = min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1]) + 1

                if dp[i][j] > maxLen:
                    maxLen = dp[i][j]
                    r, c = i, j

    return (r - maxLen + 1, c - maxLen + 1, maxLen)

# 示例输入矩阵
matrix = [
    [1, 0, 1, 0, 0],
    [1, 0, 1, 1, 1],
    [1, 1, 1, 1, 1],
    [1, 0, 0, 1, 0]
]

result = findLargestSquareMatrix(matrix)
print("最大正方子矩阵的左上角位置：({}, {})".format(result[0], result[1]))
print("最大正方子矩阵的边长：{}".format(result[2]))

该算法的时间复杂度为O(m*n)，其中m和n分别为矩阵的行数和列数。在实际应用中，可以根据具体场景进行优化，例如使用滚动数组来降低空间复杂度。