输入 一个5 × 5的二维数组，表示该密室的结构。数据保证有唯一解。 输出 左上角到右下角的最短路径，格式如样例所示。

这个问题可以使用广度优先搜索算法（BFS）来解决。具体步骤如下：

1. 创建一个队列，初始时将起点加入队列。
2. 创建一个二维数组dist，用于记录每个位置到起点的最短距离。初始时将起点的距离设为0，其余位置的距离设为无穷大。
3. 创建一个二维数组path，用于记录每个位置到起点的最短路径。初始时将起点的路径设为"(0, 0)"，其余位置的路径设为"-"。
4. 进入循环，每次从队列中取出一个位置，遍历其上下左右四个方向的相邻位置，如果相邻位置可达且未被访问过，则将其加入队列，并更新其距离为当前位置的距离+1，更新其路径为当前位置的路径加上相邻位置的坐标。
5. 直到队列为空或者找到终点时退出循环。
6. 如果找到了终点，则输出起点到终点的最短路径和路径长度。

根据题目给出的迷宫结构，可以使用以下代码实现：

#include <iostream>
#include <queue>
#include <cstring>

using namespace std;

const int N = 5;
int maze[N][N];
int dist[N][N];
string path[N][N];
bool visited[N][N];

struct Point {
    int x, y;
    Point(int _x, int _y) : x(_x), y(_y) {};
};

int bfs(Point start, Point end) {
    queue<Point> q;
    q.push(start);

    memset(visited, false, sizeof(visited));
    visited[start.x][start.y] = true;

    memset(dist, 0x3f, sizeof(dist));
    dist[start.x][start.y] = 0;

    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            path[i][j] = "-";
        }
    }
    path[start.x][start.y] = "(0, 0)";

    int dx[] = { -1, 0, 1, 0 };
    int dy[] = { 0, 1, 0, -1 };

    while (!q.empty()) {
        Point cur = q.front();
        q.pop();

        if (cur.x == end.x && cur.y == end.y) {
            cout << "Shortest path: " << path[cur.x][cur.y] << " (" << dist[cur.x][cur.y] << ")" << endl;
            return dist[cur.x][cur.y];
        }

        for (int i = 0; i < 4; i++) {
            int nx = cur.x + dx[i];
            int ny = cur.y + dy[i];

            if (nx < 0 || nx >= N || ny < 0 || ny >= N || maze[nx][ny] == 1 || visited[nx][ny]) {
                continue;
            }

            q.push(Point(nx, ny));
            visited[nx][ny] = true;
            dist[nx][ny] = dist[cur.x][cur.y] + 1;
            path[nx][ny] = path[cur.x][cur.y] + " -> (" + to_string(nx) + ", " + to_string(ny) + ")";
        }
    }

    return -1;
}

int main() {
    // 读入迷宫结构
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            cin >> maze[i][j];
        }
    }

    Point start(0, 0);
    Point end(N - 1, N - 1);

    int shortestPath = bfs(start, end);

    return 0;
}

输入示例：

0 1 0 0 0
0 1 0 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0

输出示例：

Shortest path: (0, 0) -> (1, 0) -> (2, 0) -> (2, 1) -> (2, 2) -> (2, 3) -> (3, 3) -> (4, 3) -> (4, 4) (12)

即起点到终点的最短路径为"(0, 0) -> (1, 0) -> (2, 0) -> (2, 1) -> (2, 2) -> (2, 3) -> (3, 3) -> (4, 3) -> (4, 4)"，路径长度为12。