编写以下程序：用java和Dijkstra 算法编写迷宫最短路径查找

好的，以下是Java实现Dijkstra算法查找迷宫最短路径的代码，建议在IDE中运行：

import java.util.*;

public class DijkstraMazeSolver {
    private static final int INF = Integer.MAX_VALUE; // 无穷大
    private static final int[] DIRS = {-1, 0, 1, 0, -1}; // 方向数组

    public static void main(String[] args) {
        // 迷宫地图
        int[][] maze = {
                {0, 0, 1, 0, 0, 0},
                {0, 0, 1, 0, 0, 0},
                {0, 0, 0, 0, 1, 0},
                {0, 1, 1, 1, 0, 0},
                {0, 0, 0, 0, 0, 1},
                {0, 0, 1, 0, 0, 0}
        };

        // 起点和终点
        int startX = 0, startY = 0;
        int endX = 5, endY = 5;

        // 使用Dijkstra算法求解最短路径
        int[][] dist = dijkstra(maze, startX, startY);

        // 输出最短距离和路径
        System.out.println("最短距离：" + dist[endX][endY]);
        System.out.println("最短路径：" + getPath(dist, endX, endY));
    }

    // Dijkstra算法求解最短路径
    private static int[][] dijkstra(int[][] maze, int startX, int startY) {
        int m = maze.length, n = maze[0].length;
        int[][] dist = new int[m][n]; // 起点到每个点的最短距离
        boolean[][] visited = new boolean[m][n]; // 是否访问过
        PriorityQueue<int[]> pq = new PriorityQueue<>(Comparator.comparingInt(a -> a[2])); // 小根堆

        // 初始化
        for (int i = 0; i < m; i++) {
            Arrays.fill(dist[i], INF);
        }
        dist[startX][startY] = 0;
        pq.offer(new int[]{startX, startY, 0});

        // Dijkstra算法
        while (!pq.isEmpty()) {
            int[] cur = pq.poll();
            int x = cur[0], y = cur[1], d = cur[2];
            if (visited[x][y]) {
                continue;
            }
            visited[x][y] = true;

            // 更新相邻节点的最短距离
            for (int k = 0; k < 4; k++) {
                int nx = x + DIRS[k], ny = y + DIRS[k + 1];
                if (nx >= 0 && nx < m && ny >= 0 && ny < n && maze[nx][ny] == 0 && !visited[nx][ny]) {
                    int nd = d + 1;
                    if (nd < dist[nx][ny]) {
                        dist[nx][ny] = nd;
                        pq.offer(new int[]{nx, ny, nd});
                    }
                }
            }
        }

        return dist;
    }

    // 获取最短路径
    private static String getPath(int[][] dist, int endX, int endY) {
        int m = dist.length, n = dist[0].length;
        StringBuilder sb = new StringBuilder();
        int x = endX, y = endY;

        while (dist[x][y] != INF) {
            sb.insert(0, String.format("(%d, %d) ", x, y));
            for (int k = 0; k < 4; k++) {
                int nx = x + DIRS[k], ny = y + DIRS[k + 1];
                if (nx >= 0 && nx < m && ny >= 0 && ny < n && dist[nx][ny] == dist[x][y] - 1) {
                    x = nx;
                    y = ny;
                    break;
                }
            }
        }

        return sb.toString();
    }
}

以上代码使用了Dijkstra算法（基于贪心策略）来求解迷宫最短路径，利用PriorityQueue实现了小根堆优化，时间复杂度为O(mnlog(mn))。可以根据实际情况进行修改。