Java程序用于矩阵或网格中两个单元格之间的最短距离

简介

这个Java程序用于在一个矩阵中计算两个单元格之间的最短距离。它使用了广度优先搜索（BFS）算法来找到最短路径。该程序基于图论，因此它可以用于任何类型的矩阵或网格，不仅限于矩形网格。

实现

输入

该程序接受三个输入参数：

1. 矩阵的行数
2. 矩阵的列数
3. 起点和终点的坐标

为了方便起见，我们将矩阵表示为一个二维整数数组。矩阵中的每个元素都是一个正整数，表示该单元格的权重。在该程序中，单元格间的距离是它们的权重（也就是它们之间的路径长度）。

下面是输入参数的代码片段：

int rows = 5;
int columns = 5;
int[][] matrix = {
    {1, 1, 0, 1, 1},
    {1, 0, 1, 0, 1},
    {1, 0, 1, 0, 0},
    {1, 0, 1, 1, 1},
    {1, 1, 1, 0, 0}
};
int startX = 0;
int startY = 0;
int endX = 4;
int endY = 3;

搜索算法

该程序使用广度优先搜索（BFS）算法来搜索矩阵中的最短路径。BFS算法的思路是从起点出发，依次遍历与其相邻的节点，直到找到终点为止。BFS算法的优势是可以找到起点到终点的最短路径。

下面是BFS算法的代码片段：

private static int bfs(int[][] matrix, int startX, int startY, int endX, int endY) {
    int[] dx = {-1, 0, 1, 0};
    int[] dy = {0, 1, 0, -1};

    Queue<int[]> queue = new LinkedList<>();
    boolean[][] visited = new boolean[matrix.length][matrix[0].length];
    int[][] distance = new int[matrix.length][matrix[0].length];

    queue.add(new int[]{startX, startY});
    visited[startX][startY] = true;
    distance[startX][startY] = 0;

    while (!queue.isEmpty()) {
        int[] current = queue.poll();
        int x = current[0];
        int y = current[1];

        if (x == endX && y == endY) {
            return distance[x][y];
        }

        for (int i = 0; i < 4; i++) {
            int nextX = x + dx[i];
            int nextY = y + dy[i];

            if (nextX >= 0 && nextX < matrix.length && nextY >= 0 && nextY < matrix[0].length
                    && !visited[nextX][nextY] && matrix[nextX][nextY] == 1) {
                queue.add(new int[]{nextX, nextY});
                visited[nextX][nextY] = true;
                distance[nextX][nextY] = distance[x][y] + 1;
            }
        }
    }

    return -1;
}

输出

该程序的输出是起点到终点的最短距离。如果该距离不存在，则返回-1。

下面是输出的代码片段：

int shortestDistance = bfs(matrix, startX, startY, endX, endY);
System.out.println("The shortest distance is: " + shortestDistance);

示例

下面是一个完整的示例：

public class ShortestDistance {
    public static void main(String[] args) {
        int rows = 5;
        int columns = 5;
        int[][] matrix = {
                {1, 1, 0, 1, 1},
                {1, 0, 1, 0, 1},
                {1, 0, 1, 0, 0},
                {1, 0, 1, 1, 1},
                {1, 1, 1, 0, 0}
        };
        int startX = 0;
        int startY = 0;
        int endX = 4;
        int endY = 3;

        int shortestDistance = bfs(matrix, startX, startY, endX, endY);
        System.out.println("The shortest distance is: " + shortestDistance);
    }

    private static int bfs(int[][] matrix, int startX, int startY, int endX, int endY) {
        int[] dx = {-1, 0, 1, 0};
        int[] dy = {0, 1, 0, -1};

        Queue<int[]> queue = new LinkedList<>();
        boolean[][] visited = new boolean[matrix.length][matrix[0].length];
        int[][] distance = new int[matrix.length][matrix[0].length];

        queue.add(new int[]{startX, startY});
        visited[startX][startY] = true;
        distance[startX][startY] = 0;

        while (!queue.isEmpty()) {
            int[] current = queue.poll();
            int x = current[0];
            int y = current[1];

            if (x == endX && y == endY) {
                return distance[x][y];
            }

            for (int i = 0; i < 4; i++) {
                int nextX = x + dx[i];
                int nextY = y + dy[i];

                if (nextX >= 0 && nextX < matrix.length && nextY >= 0 && nextY < matrix[0].length
                        && !visited[nextX][nextY] && matrix[nextX][nextY] == 1) {
                    queue.add(new int[]{nextX, nextY});
                    visited[nextX][nextY] = true;
                    distance[nextX][nextY] = distance[x][y] + 1;
                }
            }
        }

        return -1;
    }
}

总结

该Java程序用广度优先搜索算法计算了矩阵中两个单元格之间的最短距离。通过这个程序，我们可以看出如何使用BFS算法来解决最短路径问题。这个程序不仅仅可以用于矩形网格，还可以用于其他类型的网格。