Java 2D阵列从A点到B点的最短路径（有障碍物）

目标：找到到达目的地所需的最少移动量

场景：在具有以下元素的2D阵列8*8中：

*......B
........
****.**.
.A....*.
........
....**..
........
....*...

在哪里

• “A”代表起点
• “B”表示目的地
• “*”表示障碍
• “.”表示一个空单元格

目前我已经完成了以下代码：

import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;

class main
{
    public static void main(String args[]) throws FileNotFoundException,IOException
    {   
        FileInputStream FS = new FileInputStream("path.in");
        DataInputStream DS = new DataInputStream(FS);
        BufferedReader buffer = new BufferedReader(new InputStreamReader(DS));

        String strLine = buffer.readLine();             
        int testCase = Integer.parseInt(strLine);

        int R,C;

        for(int i = 0;i < testCase;i++)
        {           

            strLine = buffer.readLine();                    
            String input[] = strLine.split(" ");

            R = Integer.parseInt(input[0]);
            C = Integer.parseInt(input[1]);

            char[][] array = new char[R][C];

            int sCoordX = 0;
            int sCoordY = 0;
            int eCoordX = 0;
            int eCoordY = 0;

            for(int j = 0; j < R ; j++)
            {
                strLine = buffer.readLine();        

                for(int k = 0;k < C;k++)
                {                               
                    array[j][k] = strLine.charAt(k);
                    if(array[j][k] == 'A')
                    {
                        sCoordX = j;
                        sCoordY = k;
                    }

                    if(array[j][k] == 'B')
                    {
                        eCoordX = j;
                        eCoordY = k;
                    }
                }   
            }

            boolean reached = false;
            int counter = 0;
            int posX = sCoordX;
            int posY = sCoordY;
            while(!reached)
            {
                if(array[posX][posY] == 'B')
                {
                    reached = true;
                    System.out.println("You are in goal!");
                    System.out.println(array[posX][posY]);
                    System.out.println("Number of steps:"+counter);
                }

                if(!reached && posX > eCoordX)
                {
                        posX--;
                        counter++;                  
                }
                else if(!reached && posX < eCoordX)
                {
                    posX++;
                    counter++;                  
                }

                if(!reached && posY > eCoordY)
                {
                    posY--;
                    counter++;          
                }
                else if(!reached && posY < eCoordY)
                {
                    posY++;
                    counter++;              
                }
            }
        }   
    }
}

导入java.io.BufferedReader；
导入java.io.DataInputStream；
导入java.io.FileInputStream；
导入java.io.FileNotFoundException；
导入java.io.IOException；
导入java.io.InputStreamReader；
班长
{
公共静态void main（字符串args[]）抛出FileNotFoundException、IOException
{   
FileInputStream FS=新的FileInputStream（“path.in”）；
DataInputStream DS=新的DataInputStream（FS）；
BufferedReader buffer=新的BufferedReader（新的InputStreamReader（DS））；
字符串strLine=buffer.readLine（）；
int testCase=Integer.parseInt（strLine）；
int R，C；
for（int i=0；ieCoordX）
{
posX--；
计数器++；
}
如果（！达到&&posXECORDY）
{
波西--；
计数器++；
}
否则如果（！到达和位置

它的工作是找到到达目的地所需的最短数量的步骤，然而它将考虑任何事物/障碍物作为它可以移动到的空细胞。

我目前无法找到一种编码方式，使其能够识别下一个动作的正确决策

我正在考虑使用数组列表和一些算法，但是我试着阅读了一些算法，例如，但是它看起来非常混乱，有人能帮助我以一种非常简单的方式理解它，用java实现它吗

---

//-（对不起，我的编码技能，我还是个初学者）

这项任务不需要任何特殊算法，只需要在图形中进行广度优先搜索。考虑在1步可到达的点作为图形的第一层，点THATS可以在2个步骤中达到（那些连接到第一个级别的任何点，而不是源点）作为第二个级别，等等< /P> 首先访问源点可直接访问的点，然后访问第二级点，然后访问第三级点。可以通过将节点存储在列表中来实现这一点。首先访问源，并将相邻节点推到列表的末尾。然后访问列表中的每个节点，并将它们的相邻节点推到列表的末尾（如果它们目前不在列表中）。一旦到达目标节点，就完成了。您可以存储每个节点的级别，也可以存储前面的节点，以便从目标节点向后查找路径

需要注意的一件重要事情是：不要在列表中添加障碍物，这样就不会有路线穿过该点