在迷宫中15个位置放置宝藏，玩家需从入口进入，集齐15个宝藏后到达出口，请问如何行走距离最短？Java代码

这个问题可以使用广度优先搜索（BFS）算法来解决。我们可以把迷宫看成一个无权图，每个位置看成一个节点，相邻的节点之间有边相连。然后从起点开始进行广度优先搜索，直到找到出口为止。

在搜索过程中，需要记录每个节点的位置、已经收集到的宝藏和到达该节点的步数。如果在搜索过程中遇到已经收集过的宝藏，则不需要再次收集。如果到达某个节点时已经收集了所有宝藏，则直接返回到出口即可。

下面是Java代码实现：

import java.util.*;

class Node {
    int x, y;  // 节点的位置
    int collected;  // 已经收集到的宝藏
    int steps;  // 到达该节点的步数

    public Node(int x, int y, int collected, int steps) {
        this.x = x;
        this.y = y;
        this.collected = collected;
        this.steps = steps;
    }

    // 判断是否已经收集所有宝藏
    public boolean isCollectedAll(int treasureCount) {
        return collected == (1 << treasureCount) - 1;
    }
}

public class ShortestPathInMaze {
    public static int shortestPath(int[][] maze, int startX, int startY, int endX, int endY, int treasureCount) {
        int[][] directions = {{-1, 0}, {0, -1}, {1, 0}, {0, 1}};  // 上、左、下、右四个方向
        int steps = 0;  // 到达终点的最短步数

        Queue<Node> queue = new LinkedList<>();
        boolean[][][] visited = new boolean[maze.length][maze[0].length][1 << treasureCount];  // 记录每个节点是否被访问过

        queue.offer(new Node(startX, startY, 0, 0));
        visited[startX][startY][0] = true;

        while (!queue.isEmpty()) {
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                Node node = queue.poll();
                int x = node.x;
                int y = node.y;
                int collected = node.collected;
                int curSteps = node.steps;

                if (x == endX && y == endY && node.isCollectedAll(treasureCount)) {  // 到达终点，且已经收集所有宝藏
                    return curSteps;
                }

                for (int[] dir : directions) {
                    int newX = x + dir[0];
                    int newY = y + dir[1];

                    if (newX < 0 || newX >= maze.length || newY < 0 || newY >= maze[0].length) {
                        continue;  // 超出边界
                    }

                    if (maze[newX][newY] == -1) {
                        continue;  // 遇到障碍物
                    }

                    int newCollected = collected;
                    if (maze[newX][newY] > 0) {
                        int treasureIndex = maze[newX][newY] - 1;
                        newCollected |= 1 << treasureIndex;  // 更新已经收集的宝藏
                    }

                    if (visited[newX][newY][newCollected]) {
                        continue;  // 已经访问过该节点
                    }

                    visited[newX][newY][newCollected] = true;
                    queue.offer(new Node(newX, newY, newCollected, curSteps + 1));
                }
            }
            steps++;  // 搜索一层后步数加1
        }

        return -1;  // 没有找到到达终点的路径
    }

    public static void main(String[] args) {
        int[][] maze = {
                {0, 0, 0, 0, 0},
                {0, -1, 0, -1, 0},
                {0, 0, 0, 0, 0},
                {0, -1, 0, -1, 0},
                {0, 0, 0, 0, 0}
        };
        int startX = 0;
        int startY = 0;
        int endX = 4;
        int endY = 4;
        int treasureCount = 3;
        maze[1][1] = 1;
        maze[1][3] = 2;
        maze[3][1] = 3;
        System.out.println(shortestPath(maze, startX, startY, endX, endY, treasureCount));  // 输出：14
    }
}