Question

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

场景：在2D数组8 * 8中包含如下元素：

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

，其中

＆＃34; A＆＃34;代表起点。
＆＃34; B＆＃34;代表目的地点。
＆＃34; *＆＃34;代表一个障碍。
＆＃34; 。＆＃34;代表一个空单元格。

目前我已完成以下代码：

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

它的工作是找到＆＃34;最短的＆＃34;到达目的地所需的步骤数量，但它会将任何/障碍物视为可以移动到的空单元格。

我目前无法找到一种方法来对其进行编码，使其能够识别下一次移动的正确决定。

我正在考虑使用数组列表和一些算法，但我尝试阅读一些算法，例如Dijkstra's algorithm，但它看起来真的很混乱，任何人都可以帮助我以非常简单的方式理解它它在java？

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

Answer 1

此任务不需要任何特殊算法，只需在图表中进行广度优先搜索。考虑在1步中可到达的点作为图的第一级，可以分2步到达的点（那些连接到任何第一级点，但不连接到源点）作为第二级等。

首先访问可从源点直接到达的点，然后访问第二级点，然后访问第三级点。您可以通过将节点存储在列表中来实现此目的。首先，您访问源，并将相邻节点推送到列表的末尾。然后，您访问列表中的每个节点，并将其相邻节点推送到列表的末尾（如果它们到目前为止不在列表中）。到达目标节点后，您就完成了。您可以存储每个节点的级别，还可以存储前一个节点，以便从目标节点向后查找路径。

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

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

1 个答案: