C# 访问二维阵列中某个位置的相邻位置

我有以下二维数组：

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（intx，inty）的方法。当我们击中数组中的一个0时（即击中（0，0），击中（1，1），但不击中（3，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 },
};

你知道我该怎么做吗？在我看来，深度优先搜索/递归算法应该可以完成这项工作，但我还没有能够在2d数组中实现它

---

谢谢你的帮助

我想说，您应该能够使用递归方法来实现这一点

差不多

    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);
        }
    }

私有无效命中（int[，]arr，int x，int y）
{
如果（
x<0||
x+1>arr.GetLongLength（0）||
y<0||
y+1>arr.GetLongLength（1）
)
返回；
如果（arr[x，y]==0）
{
arr[x，y]+=10；
命中率（arr、x、y+1）；
命中率（arr，x+1，y+1）；
命中率（arr，x+1，y）；
命中率（arr，x+1，y-1）；
命中率（arr，x，y-1）；
命中率（arr，x-1，y-1）；
命中率（arr，x-1，y）；
}
}

我想说，您应该能够使用递归方法实现这一点

差不多

    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);
        }
    }

私有无效命中（int[，]arr，int x，int y）
{
如果（
x<0||
x+1>arr.GetLongLength（0）||
y<0||
y+1>arr.GetLongLength（1）
)
返回；
如果（arr[x，y]==0）
{
arr[x，y]+=10；
命中率（arr、x、y+1）；
命中率（arr，x+1，y+1）；
命中率（arr，x+1，y）；
命中率（arr，x+1，y-1）；
命中率（arr，x，y-1）；
命中率（arr，x-1，y-1）；
命中率（arr，x-1，y）；
}
}

您需要的是一种算法，您可以通过各种方式实现，从（观察堆栈）到

您还可以稍微收紧代码，但下面是我（使用DFS）将要做的大致情况：

int[]dx={1,1,1,0,0，-1，-1，-1}；
int[]dy={1,0，-1,1，-1,1,0}；
无效命中（整数x，整数y）{
如果（电路板[x，y]==0）{
板[x，y]=10；
对于（int i=0；i<8；i++）{
nx=x+dx[i]；
ny=y+dy[i]；
//如果nx，则ny处于绑定状态
如果（nx>=0&&nx=0&&ny

您需要的是一种算法，您可以通过各种方式实现，从（观察堆栈）到

您还可以稍微收紧代码，但下面是我（使用DFS）将要做的大致情况：

int[]dx={1,1,1,0,0，-1，-1，-1}；
int[]dy={1,0，-1,1，-1,1,0}；
无效命中（整数x，整数y）{
如果（电路板[x，y]==0）{
板[x，y]=10；
对于（int i=0；i<8；i++）{
nx=x+dx[i]；
ny=y+dy[i]；
//如果nx，则ny处于绑定状态
如果（nx>=0&&nx=0&&ny

我个人认为用递归方法来实现这一点很奇怪。我只是把它当作一个图像处理任务，并在整个阵列中运行一个过滤器。

我个人认为用递归方法这样做很奇怪。我只是把它当作一个图像处理任务，在整个阵列中运行一个过滤器。

你能提供更多的例子吗？你能提供更多的例子吗？