java二维数组求最短路径

原创

mob64ca12e7b5cf 2024-10-07 05:28:20 ©著作权

©著作权归作者所有：来自51CTO博客作者mob64ca12e7b5cf的原创作品，请联系作者获取转载授权，否则将追究法律责任

Java二维数组求最短路径

在计算机科学中，最短路径问题是一个经典问题，常见于图论和算法设计中。今天，我们将一起学习如何在Java中实现一个简单的二维数组求最短路径的算法。

1. 整体流程

为了解决这个问题，我们可以将其分为若干个步骤。下面是一个简单的步骤表格：

步骤	说明
1	创建一个二维数组，表示图的结构
2	定义起点和终点
3	实现算法（如BFS、Dijkstra等）
4	追踪路径
5	输出最短路径

接下来，我们将逐步详细讨论这些步骤。

2. 步骤详解

2.1 创建一个二维数组表示图的结构

首先，我们需要创建一个二维数组，表示我们的图。在Java中，使用如下代码：

int[][] grid = {
    {0, 1, 0, 0, 0},
    {0, 1, 0, 1, 0},
    {0, 0, 0, 1, 0},
    {0, 1, 0, 0, 0},
    {0, 0, 0, 1, 0}
};

注释: 在这个数组中，0代表可通行的路径，而1代表障碍物。

2.2 定义起点和终点

接下来，定义起点和终点，使用如下代码：

int[] start = {0, 0}; // 起点
int[] end = {4, 4}; // 终点

注释: 这里，起点为(0,0)，终点为(4,4)。

2.3 实现算法（以广度优先搜索BFS为例）

在这里，我们使用广度优先搜索（BFS）来寻找最短路径。BFS是一个高效的图搜索算法，可以找到从起点到终点的最短路径。

import java.util.LinkedList;
import java.util.Queue;

class Node {
    int x, y, dist;
    
    Node(int x, int y, int dist) {
        this.x = x;
        this.y = y;
        this.dist = dist;
    }
}

public class ShortestPath {
    private static final int[][] directions = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
    
    public static int bfs(int[][] grid, int[] start, int[] end) {
        Queue<Node> queue = new LinkedList<>();
        boolean[][] visited = new boolean[grid.length][grid[0].length];
        
        queue.offer(new Node(start[0], start[1], 0));
        visited[start[0]][start[1]] = true;
        
        while (!queue.isEmpty()) {
            Node current = queue.poll();
            
            // 检查是否到达终点
            if (current.x == end[0] && current.y == end[1]) {
                return current.dist; // 返回最短路径长度
            }
            
            // 遍历四个方向
            for (int[] dir : directions) {
                int newX = current.x + dir[0];
                int newY = current.y + dir[1];
                
                // 检查合法性
                if (isValid(grid, newX, newY, visited)) {
                    visited[newX][newY] = true;
                    queue.offer(new Node(newX, newY, current.dist + 1));
                }
            }
        }
        
        return -1; // 如果无法到达终点
    }
    
    private static boolean isValid(int[][] grid, int x, int y, boolean[][] visited) {
        return (x >= 0 && x < grid.length && y >= 0 && y < grid[0].length
                && grid[x][y] == 0 && !visited[x][y]);
    }
}

注释:

Node类用于表示一个节点。
bfs方法实现广度优先搜索逻辑。
isValid方法用于检查新位置是否合法。

2.4 追踪路径

追踪路径可通过记录路径来实现。在这里，我们可以在Node类中添加一个parent属性。

class Node {
    int x, y, dist;
    Node parent; // 添加parent属性
    
    Node(int x, int y, int dist, Node parent) {
        this.x = x;
        this.y = y;
        this.dist = dist;
        this.parent = parent; // 建立父节点关系
    }
}

更新bfs方法以记录父节点：

// 在找到新位置时，设定parent节点
queue.offer(new Node(newX, newY, current.dist + 1, current));

2.5 输出最短路径

最后，遍历从终点到起点的路径：

public static void printPath(Node node) {
    if (node == null) return;
    printPath(node.parent);
    System.out.println("(" + node.x + ", " + node.y + ")");
}

在主方法中调用printPath：

Node resultNode = bfs(grid, start, end);
printPath(resultNode); // 输出路径

3. 类图

下面是使用 Mermaid 语法表示的类图：

classDiagram
    class Node {
        int x
        int y
        int dist
        Node parent
        +Node(int x, int y, int dist, Node parent)
    }

    class ShortestPath {
        +int bfs(int[][] grid, int[] start, int[] end)
        +boolean isValid(int[][] grid, int x, int y, boolean[][] visited)
        +void printPath(Node node)
    }

    ShortestPath --> Node