动态规划分析Bool矢量向量

时间:2014-04-17 19:28:49

标签: c++ dynamic vector

这是我要解决的问题。

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

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

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

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

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

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

2 个答案:

答案 0 :(得分:0)

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

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

答案 1 :(得分:0)

这是我的提名。动态编程,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;
}