定义一个二维数组：int maze[5][5]={{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}}它表示一个迷宫其中的1表示墙壁0表示出口写出它从左上角到右下角的最短路径

这道题可以使用广度优先搜索（BFS）来解决。我们从起点开始，一层一层地向外扩展，直到找到终点为止。

首先，我们需要定义一个结构体来表示迷宫中的一个位置，包括该位置的行和列以及到起点的距离。同时，我们需要定义一个队列，用于存储待扩展的位置。

#include <iostream>
#include <queue>

using namespace std;

struct Node {
    int x, y; // 行和列
    int dist; // 到起点的距离
};

int maze[5][5] = {
    {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}
};

int dx[4] = {-1, 0, 1, 0}; // 上下左右四个方向的行偏移量
int dy[4] = {0, 1, 0, -1}; // 上下左右四个方向的列偏移量

int bfs() {
    queue<Node> q;
    bool vis[5][5] = {false}; // 标记每个位置是否已经访问过
    q.push({0, 0, 0});
    vis[0][0] = true;
    while (!q.empty()) {
        Node curr = q.front();
        q.pop();
        if (curr.x == 4 && curr.y == 4) { // 如果已经到达终点，则返回距离
            return curr.dist;
        }
        for (int i = 0; i < 4; i++) { // 扩展四个方向
            int nx = curr.x + dx[i];
            int ny = curr.y + dy[i];
            if (nx >= 0 && nx < 5 && ny >= 0 && ny < 5 && maze[nx][ny] == 0 && !vis[nx][ny]) {
                q.push({nx, ny, curr.dist + 1});
                vis[nx][ny] = true;
            }
        }
    }
    return -1; // 如果无法到达终点，则返回 -1
}

int main() {
    cout << bfs() << endl; // 输出最短路径的长度
    return 0;
}

输出结果为 `8`，表示从左上角到右下角的最短路径长度为 8。