Question

这是我要解决的问题。

考虑到一个方块的bools，我想找到最大的子方块的大小，完全充满了trues（1）。此外，我允许O（n ^ 2）内存要求以及运行时间必须为O（n ^ 2）。该函数的标题将如下所示

 unsigned int largestCluster(const vector<vector<bool>> &map);

其他一些需要注意的事情是，总会有至少一个1（1 x 1子方格），输入也总是正方形。

现在我尝试解决这个问题：鉴于这是基于动态编程的概念，根据我的有限理解，它有助于存储以前发现以供以后使用的信息。因此，如果我的理解是纠正，Prim的算法将是动态算法的一个例子，因为它记住我们访问过的顶点，到顶点的最小距离，以及启用最小距离的父节点。

我尝试分析地图并跟踪真实邻居的数量，真正的位置位置。我在想，如果一个地方有4个真正的邻居，那么这是一个潜在的子方格。但是，这对尺寸为4或更小的子方形没有帮助。

我试图在这个问题中包含很多细节以寻求帮助，因为我正在尝试游戏计划解决这个问题的方法，因为我不相信它需要编写一个冗长的函数。谢谢你的帮助

Answer 1

如果你想要一个动态编程方法我可以想到的一个策略是将一个盒子（基本案例1条目）视为一个较大盒子的潜在左上角，并从大方块的右下角开始，然后，您需要仅评估“框”（使用先前存储的信息，仅考虑到目前为止最大的聚类），这些框位于我们正在评估的右侧，底部和对角线右侧底部。通过保存关于每个边缘的信息，我们将尊重O（n ^ 2）（尽管不是o（n ^ 2））但是对于运行时，您需要处理到达O的方法的细节（n ^ 2）

这只是一个粗略的草案，因为我没有太多时间，我将不胜感激任何关于此的提示/评论。

Answer 2

这是我的提名。动态编程，O（n ^ 2）复杂度。我意识到我可能只做过某人的家庭作业，但这看起来像是一个有趣的小问题。

int largestCluster(const std::vector<std::vector<bool> > a)
{
    const int n = a.size();
    std::vector<std::vector<short> > s;
    s.resize(n);
    for (int i = 0; i < n; ++i)
    {
        s[i].resize(n);
    }

    s[0][0] = a[0][0] ? 1 : 0;
    int maxSize = s[0][0];

    for (int k = 1; k < n; ++k)
    {
        s[k][0] = a[k][0] ? 1 : 0;
        for (int j = 1; j < k; ++j)
        {
            if (a[k][j])
            {
                int m = s[k - 1][j - 1];
                if (s[k][j - 1] < m)
                {
                    m = s[k][j - 1];
                }
                if (s[k - 1][j] < m)
                {
                    m = s[k - 1][j];
                }
                s[k][j] = ++m;

                if (m > maxSize)
                {
                    maxSize = m;
                }
            }
            else
            {
                s[k][j] = 0;
            }
        }

        s[0][k] = a[0][k] ? 1 : 0;
        for (int i = 1; i <= k; ++i)
        {
            if (a[i][k])
            {
                int m = s[i - 1][k - 1];
                if (s[i - 1][k] < m)
                {
                    m = s[i - 1][k];
                }
                if (s[i][k - 1] < m)
                {
                    m = s[i][k - 1];
                }
                s[i][k] = ++m;

                if (m > maxSize)
                {
                    maxSize = m;
                }
            }
            else
            {
                s[i][k] = 0;
            }
        }
    }

    return maxSize;
}

动态规划分析Bool矢量向量

2 个答案: