Question

我有以下二维数组：

static int[,] arr = new int[5, 5] 
{ 
    { 00, 00, 00, 01, 00 },
    { 00, 00, 01, 01, 00 },
    { 00, 00, 01, 01, 00 },
    { 00, 00, 01, 01, 00 },
    { 00, 00, 00, 01, 00 },
};

我必须实现一个名为Hit（int x，int y）的方法。当我们在数组中遇到0时（即Hit（0,0），Hit（1,1），但不是Hit（3,0））我希望所有相邻的零到0我们命中的增加10因此，如果我调用Hit（1,1），则数组应该变为以下内容。

static int[,] arr = new int[5, 5] 
{ 
    { 10, 10, 10, 01, 00 },
    { 10, 10, 01, 01, 00 },
    { 10, 10, 01, 01, 00 },
    { 10, 10, 01, 01, 00 },
    { 10, 10, 10, 01, 00 },
};

知道如何实现它吗？听起来像深度优先搜索/递归排序算法应该可以完成这项工作，但我无法为二维数组实现它。

感谢您的帮助！

Answer 1

您正在寻找的是Flood fill算法，您可以通过各种方式实施该算法，从DFS（观看堆栈）到BFS。

您也可以稍微收紧一下代码，但这里是我将要做的事情（使用DFS）的粗略草图：

int[] dx = { 1, 1, 1, 0, 0, -1, -1, -1 };
int[] dy = { 1, 0, -1, 1, -1, 1, -1, 0 };
void Hit( int x, int y ) {
    if ( board[x,y] == 0 ) {
        board[x,y] = 10;
        for ( int i = 0; i < 8; i++ ) {
            nx = x + dx[i];
            ny = y + dy[i];

            // if nx, ny is in bound
            if ( nx >= 0 && nx < height && ny >= 0 && ny < height )
                Hit( nx, ny );
        }
    }
}

Answer 2

我会说你应该能够用递归方法做到这一点。

像

这样的东西

    private void Hit(int[,] arr, int x, int y)
    {
        if (    
                x < 0 ||
                x + 1 > arr.GetLongLength(0)||
                y < 0 ||
                y + 1 > arr.GetLongLength(1)
            )
            return;
        if (arr[x, y] == 0)
        {
            arr[x, y] += 10;
            Hit(arr, x, y + 1);
            Hit(arr, x + 1, y + 1);
            Hit(arr, x + 1, y);
            Hit(arr, x + 1, y - 1);
            Hit(arr, x, y - 1);
            Hit(arr, x - 1, y - 1);
            Hit(arr, x - 1, y);
        }
    }

Answer 3

我个人认为用递归方法做这件事很奇怪。我只是将其视为图像处理任务，并在数组中运行过滤器。

访问二维阵列中某个位置的邻居

3 个答案: