如何在二维数组中计数数组

How to count groups of numbers in two dimensional array?

本文关键字：数数 数组 二维数组      更新时间：2023-10-16

我的字段来自二维数组，其中1是一块土地，而0是什么。当两块土地停留在同一墙上时，被称为邻居。当一块土地没有邻居时，被称为岛屿，而当它有两个或两个以上的邻居时，被称为大陆。我必须计算田野上的所有岛屿和大陆。这就是我找到岛屿的方式。

int find_islands(const int array[][8]) { // Find the islands in the field.
int count = 0;
for (int i = 0; i < 8; i++)
{
    for (int x = 0; x < 8; x++)
    {
        if (array[i][x] == 1)
        {
            if (i == 0)
            {
                if (x == 0)
                {
                    if (array[i][x + 1] == 0 && array[i + 1][x] == 0)
                    {
                        count++;
                    }
                }
                else if (x == 7)
                {
                    if (array[i][x - 1] == 0 && array[i + 1][x] == 0)
                    {
                        count++;
                    }
                }
                else
                {
                    if (array[i][x + 1] == 0 && array[i][x - 1] == 0 && array[i + 1][x] == 0)
                    {
                        count++;
                    }
                }
            }
            else if (i == 7)
            {
                if (x == 0)
                {
                    if (array[i][x + 1] == 0 && array[i - 1][x] == 0)
                    {
                        count++;
                    }
                }
                else if (x == 7)
                {
                    if (array[i][x - 1] == 0 && array[i - 1][x] == 0)
                    {
                        count++;
                    }
                }
                else
                {
                    if (array[i][x + 1] == 0 && array[i][x - 1] == 0 && array[i - 1][x] == 0)
                    {
                        count++;
                    }
                }
            }
            else
            {
                if (x == 0)
                {
                    if (array[i][x + 1] == 0 && array[i + 1][x] == 0 && array[i - 1][x] == 0)
                    {
                        count++;
                    }
                }
                else if (x == 7)
                {
                    if (array[i][x - 1] == 0 && array[i + 1][x] == 0 && array[i - 1][x] == 0)
                    {
                        count++;
                    }
                }
                else
                {
                    if (array[i][x + 1] == 0 && array[i][x - 1] == 0 && array[i + 1][x] == 0 && array[i - 1][x] == 0)
                    {
                        count++;
                    }
                }
            }
        }
    }
}
return count;}

这是一个样品阵列。

int board[8][8] = {
    {0, 1, 0, 0, 1, 1, 0, 0},
    {0, 0, 0, 0, 0, 0, 0, 0},
    {1, 1, 0, 0, 1, 0, 0, 0},
    {1, 1, 0, 0, 1, 0, 0, 1},
    {0, 0, 0, 1, 0, 1, 0, 0},
    {0, 0, 0, 0, 0, 0, 0, 0},
    {1, 1, 1, 1, 1, 0, 0, 0},
    {1, 0, 0, 1, 1, 0, 1, 0} };

我的问题是我无法想到一种找到大陆的方法。预先感谢！

您要寻找的算法是洪水填充。为简单起见，让我们稍微更改规则，并将岛屿视为大洲。想象一下，我们扭转了场景，因此现在的土地是平坦的表面上的深孔。您可以做什么来计算大陆是反复选择您以前从未见过的洞，然后在其中倒入一堆水。

这将淹没与之连接的所有内容。当您看到一个已经被洪水淹没的地方时，您就会知道它是您以前算过的大陆的一部分，您不应该再计算它。

如何使用代码执行此操作？创建一个2D布尔阵列以存储是否被洪水淹没。我们可以称其为visited。现在，我们编写一个函数来模拟洪水过程，该过程将正方形的坐标作为开始洪水填充的位置。

我们可以使用std::queue存储我们要下一步处理的位置。每次我们处理一个正方形时，我们都会标记为访问，然后查看其相邻的正方形。如果相邻广场是一块土地，我们尚未参观过，我们将其添加到队列中。

我们现在可以在所有正方形上迭代，对于我们看到的每个正方形。然后，我们可以通过简单地柜台来跟踪我们看到一块未访问的土地并开始洪水填充的次数来计算大陆。

现在，我们知道包括大小1大洲在内的大洲总量，我们可以简单地减去岛屿数量，以使大陆数量大于一块土地。

我将实际实施作为您的练习。

相关文章：