Arrays 在给定的0'平方矩阵中求1的最大平方子矩阵；s和1'；s

以下为采访问题：

编写一个函数，输出最大平方子矩阵的大小，该子矩阵仅由1和0组成的平方矩阵中的1组成

例1：

0 1
0 0

产出：1

例2：

0 0 0
0 1 1
0 1 1

产出：2

例3：

1 1 1
1 1 1
1 1 1

产出3

---

如果可能的话，我希望能有效地解决这个问题。

使用，然后。

实施的第一个想法： 在r=1行开始搜索

找到该行中最长的一个序列，并将该长度指定给x

试着从r行开始，找到一个边长为x的正方形矩阵。如果成功，则max=x。如果不是，则减小x，如果x>1，则重复此步骤。如果未找到任何内容，则最大值可能为0或1

增加r，然后重复

然后改进您的算法（如果剩余行小于当前最大值，则停止，以此类推）。

下面是使用动态规划在C#中的O（n）实现。基本上，当您读取矩阵的每个单元格时，您正在构建另一个最大大小的矩阵（包括它本身）

    public static int LargestSquareMatrixOfOne(int[,] original_mat)
    {
        int[,] AccumulatedMatrix = new int[original_mat.GetLength(0), original_mat.GetLength(1)];
        AccumulatedMatrix[0, 0] = original_mat[0, 0];
        int biggestSize = 1;
        for (int i = 0; i < original_mat.GetLength(0); i++)
        {
            for (int j = 0; j < original_mat.GetLength(1); j++)
            {
                if (i > 0 && j > 0)
                {
                    if (original_mat[i, j] == 1)
                    {
                        AccumulatedMatrix[i, j] = Math.Min(AccumulatedMatrix[i - 1, j - 1], (Math.Min(AccumulatedMatrix[i - 1, j], AccumulatedMatrix[i, j - 1]))) + 1;
                        if (AccumulatedMatrix[i, j] > biggestSize)
                        {
                            biggestSize = AccumulatedMatrix[i, j];
                        }
                    }
                    else
                    {
                        AccumulatedMatrix[i, j] = 0;
                    }
                }
                else if ( (i > 0 && j == 0) || (j > 0 && i == 0))
                {
                    if (original_mat[i, j] == 1) { AccumulatedMatrix[i, j] = 1; }
                    else { AccumulatedMatrix[i, j] = 0; }
                }
            }
        }
        return biggestSize;
    }

public static int LargestSquareMatrixOfOne（int[，]原材料）
{
int[，]累计矩阵=新int[原始材料GetLength（0），原始材料GetLength（1）]；
累加矩阵[0,0]=原始矩阵[0,0]；
int biggestSize=1；
对于（int i=0；i0&&j>0）
{
如果（原始材料[i，j]==1）
{
累加矩阵[i，j]=Math.Min（累加矩阵[i-1，j-1]，（Math.Min（累加矩阵[i-1，j]，累加矩阵[i，j-1]））+1；
if（累计矩阵[i，j]>最大尺寸）
{
最大尺寸=累计矩阵[i，j]；
}
}
其他的
{
累加矩阵[i，j]=0；
}
}
else如果（（i>0&&j==0）|（j>0&&i==0））
{
如果（原矩阵[i，j]==1）{累加矩阵[i，j]=1；}
else{AggregatedMatrix[i，j]=0；}
}
}
}
返回最大大小；
}

到目前为止，您做了哪些工作？我们不会只为您回答这个问题。您的问题有点紧迫……我很确定，在堆栈溢出之前，可能在一两年前，这里已经问过这个确切的问题。可能的重复