Java 在二维阵列中导航时，请检查相邻元素相对于入口点的有效路径？

自提交以来，该问题的性质已发生变化，但该问题不适合删除。我已经回答了下面的问题，并将其标记为社区帖子。

我正在编写一个递归路径导航函数，我需要的最后一部分是知道您来自哪个单元格，并确定下一步要去哪里。

舞台 您将获得一个二维数组，其中

0的
表示无效路径，
1的
表示有效路径。据我所知，您可以操作正在导航的阵列的数据，因此我使用
2的
标记了一条移动路径。




目标
您需要递归地查找并打印从
原点
到
退出
的所有路径。有四个迷宫，有些有多条路径、死胡同或环路

我编写的代码可以正确处理所有这三种情况，但查找下一条路径的方法存在缺陷，因为它从相对于当前索引的固定位置开始，并检查移动路径；如果你遇到它，它应该撤退

虽然这在大多数情况下都有效，但如果它检查的第一个地方恰好是您的出生地，则会失败。此时，它返回并过早结束

因此，我需要找到一种方法，根据您的来源智能地开始扫描（顺时针或逆时针），以便该位置始终是最后检查的位置

下面是一些描述该过程的代码（注意：边缘案例在此之前已经处理过，所以我们不需要担心）：


private static void main（）
{
int StartX=；//任意X
int StartY=；//任意Y
String Path=”“；//递归调用将把它们的位置固定到此位置，并仅在找到退出路径时打印。
int[][]myArray=；//我们得到了这个数组，我只是一边编辑它
导航器（StartX、StartY、Path、myArray）；
}
专用静态void导航器（int-locX、int-locY、字符串路径、int[][]myArray）
{
int newX=0；int newY=0；
Path=Path.concat（“[”+locX+“，“+locY+”]）；
//案例1：你在迷宫的边缘
布尔值bIsOnEdge=（locX==0 | | locX==myArray.length-1 | | locY==0 | | locY==myArray[0].length-1）；
if（bIsOnEdge）
{
System.out.println（路径）；
返回；
}
int[][]环境=环绕查找器（locX、locY、myArray）；
对于（int i=0；i而言，您的问题似乎在于：

if (Surroundings[0][i] == 2)
{
    myArray[locX][locY] = 1;
    return;
}

也许这应该改为：

if (Surroundings[0][i] == 2)
{
    // not sure why you need this if it's already 1
    myArray[locX][locY] = 1;

    // go to next iteration of the "i" loop
    // and keep looking for next available path
    continue;
}

如果（环境[0][i]==1）
周围的单元格都不满足条件，则递归方法将自动返回

PS:通常使用小写字母作为变量的第一个字符。例如：
环境
，
路径
，
startX
或
myVar
解决方案
最初的目标是从头到尾打印退出阵列的所有路径

早期版本的脚本在踩踏位置上写的是“0”，而不是“2”，但出于某种原因，我认为我需要“2”，我需要区分“踩踏路径”和“无效路径”

事实上，由于问题的递归性质，我发现事实上，你可以边写0边解决问题。此外，我不再需要跟踪我的来源，而是从左到右遍历我周围的3x3矩阵，跳过我自己的单元格，而不是顺时针检查矩阵

以下是此类解决方案的完整代码。找到出口（edge）后，它将打印到控制台然后在迷宫中追踪自身，完成递归。要启动该函数，您将获得一个包含
0
和
1
的正方形2D数组，其中
1
是有效路径，而
0
无效。您还将获得一组坐标，在其中“插入”（
locX
，
locY
）以及一个累积坐标的空字符串，形成一条稍后打印出来的路径（
stringpath=”“
）

代码如下：

static void Navigator(int locX, int locY, int[][] myArray, String Path)
{
    int newX = 0;
    int newY = 0;

    Path = Path.concat("["+locX+","+locY+"]");

    if ((locX == 0 || locX == myArray.length-1 || locY == 0 || locY == myArray[0].length-1))
    {//Edge Found
        System.out.println(Path);
        pathCnt++;
        myArray[locX][locY] = 1;
        return;
    }

    for (int row = -1; row <= 1; row++)
    {            
        for (int col = -1; col <= 1; col++)
        {
            if (!(col == 0 && row == 0) && (myArray[locX+row][locY+col] == 1))
            {   //Valid Path Found
                myArray[locX][locY] = 0;
                Navigator(locX+row, locY+col, myArray, Path);
            }
        }
    }

    //Dead End Found
    myArray[locX][locY] = 1;
    return;
}       System.out.println(Path);
        pathCnt++;
        swamp[locX][locY] = 1;
        return;
    }

    for (int row = -1; row <= 1; row++)
    {            
        for (int col = -1; col <= 1; col++)
        {
            if (!(col == 0 && row == 0) && (swamp[locX+row][locY+col] == 1))
            {   //Valid Path Found
                swamp[locX][locY] = 0;
                Navigator(locX+row, locY+col, swamp, Path);
            }
        }
    }

    //Dead End Found
    swamp[locX][locY] = 1;
    return;
}

此循环仅检查
1的
，并仅在发生这种情况时再次调用该函数。为什么？因为这是倒数第二种情况。只会发生一种额外的情况，如果我们到达函数末尾，则意味着我们遇到了这种情况。为什么要编写额外的代码（检查
0的
以明确识别它

所以，正如我刚才提到的，如果我们退出
for
循环，这意味着我们根本没有遇到任何1。这意味着我们被零包围！这意味着我们已经进入了死胡同，这意味着我们所要做的就是将我们的错误从该函数实例中删除，从而得到最终的
返回；

总而言之，最终的功能很简单。但由于没有背景，必须了解这些案例的模式和意义，在尝试了几次失败后，可能需要做很多工作。我花了几天时间来完善这个

祝大家编码愉快！
我感觉这是因为您在2D数组中使用的是基元类型
int
。尝试使用
Integer
对象；希望您的Java版本支持自动装箱。只是直觉猜测，需要验证。不，请忽略这一点。数组是对象，所以它们是通过引用传递的。所以这不是原因e问题。是的，数组做浅拷贝和
Integer
autoboxes
int
。但是智能迭代中涉及的多For循环太复杂了，我自己无法计算。很抱歉，我的第一条评论是错误的。你可以在方法中修改数组，它会反映给调用方。所以你可以使用原语de>int
。无论如何，我想我找到了问题。我会写一个答案。请稍候。我已经发布了我的答案。请看一看！我发现你的递归
static void Navigator(int locX, int locY, int[][] myArray, String Path)
{
    int newX = 0;
    int newY = 0;

    Path = Path.concat("["+locX+","+locY+"]");

    if ((locX == 0 || locX == myArray.length-1 || locY == 0 || locY == myArray[0].length-1))
    {//Edge Found
        System.out.println(Path);
        pathCnt++;
        myArray[locX][locY] = 1;
        return;
    }

    for (int row = -1; row <= 1; row++)
    {            
        for (int col = -1; col <= 1; col++)
        {
            if (!(col == 0 && row == 0) && (myArray[locX+row][locY+col] == 1))
            {   //Valid Path Found
                myArray[locX][locY] = 0;
                Navigator(locX+row, locY+col, myArray, Path);
            }
        }
    }

    //Dead End Found
    myArray[locX][locY] = 1;
    return;
}       System.out.println(Path);
        pathCnt++;
        swamp[locX][locY] = 1;
        return;
    }

    for (int row = -1; row <= 1; row++)
    {            
        for (int col = -1; col <= 1; col++)
        {
            if (!(col == 0 && row == 0) && (swamp[locX+row][locY+col] == 1))
            {   //Valid Path Found
                swamp[locX][locY] = 0;
                Navigator(locX+row, locY+col, swamp, Path);
            }
        }
    }

    //Dead End Found
    swamp[locX][locY] = 1;
    return;
}

A B C
D . E
F G H