kuangbin带你飞——专题一 简单搜索（2）

kuangbin带你飞——专题一 简单搜索（2）

专题网址：VJ网址 [kuangbin带你飞]专题1-23

---

题目来源：POJ 2251 Dungeon Master

VJ题目

题解

这一题是经典迷宫问题，只不过改成三维数组，我用到BFS(广度优先搜索)。

建立队列queue，然后起点入队，从起点出发，遍历上下左右前后六个方向，将可到达的地点入队，起点出队。

当到达终点时，结束队列循环，输出结果。

AC代码

#include <iostream>
#include <algorithm>
#include <iomanip>
#include <string>
#include <cstring>
#include <vector>
#include <cmath>
#include <queue>
using namespace std;

#define inf 0x3f3f3f3f
int l, r, c;

// 地图数组 mp ，1 表示可到达的地点, 0 表示不可到达的地点
int mp[35][35][35];
// 标记数组 vis , 1 表示该地点已经到达过了
bool vis[35][35][35];

// 上下左右前后 六个方向的方向数组
int dx[6] = {-1, 1, 0, 0, 0, 0};
int dy[6] = {0, 0, 0, 0, -1, 1};
int dz[6] = {0, 0, -1, 1, 0, 0};

// 结构体，存点
struct point
{
    int x, y, z;
    // sum 表示到达该点使用多少分钟
    int sum;
};
point start, ende;

queue<point> p;

void bfs()
{
    // 队列的初始化
    while (!p.empty())
        p.pop();
    // 起点入队
    p.push(start);
    point ans;
    while (p.size())
    {
        // 出队
        ans = p.front();
        p.pop();
        // 到达终点时,结束循环
        if (ans.x == ende.x && ans.y == ende.y && ans.z == ende.z && ans.sum < ende.sum)
        {
            ende.sum = ans.sum;
            break;
        }
        // 遍历六个方向
        point to;
        for (int i = 0; i < 6; ++i)
        {
            if (mp[ans.x + dx[i]][ans.y + dy[i]][ans.z + dz[i]] == 1 && !vis[ans.x + dx[i]][ans.y + dy[i]][ans.z + dz[i]])
            {
                // 入队
                vis[ans.x + dx[i]][ans.y + dy[i]][ans.z + dz[i]] = 1;
                to.x = ans.x + dx[i], to.y = ans.y + dy[i], to.z = ans.z + dz[i], to.sum = ans.sum + 1;
                p.push(to);
            }
        }
    }
}

int main()
{
    // 多组数据
    while (~scanf("%d%d%d", &l, &r, &c))
    {
        if (l == 0 && r == 0 && c == 0)
            break;
        // 数组初始化
        memset(vis, 0, sizeof(vis));
        memset(mp, 0, sizeof(mp));
        // 控制输入数据
        string str;
        for (int i = 1; i <= l; ++i)
        {
            for (int j = 1; j <= r; ++j)
            {
                cin >> str;
                for (int k = 1; k <= c; ++k)
                {
                    // 数据为 S 时，初始化起点
                    if (str[k - 1] == 'S')
                    {
                        start.x = i, start.y = j, start.z = k;
                        start.sum = 0;
                        vis[i][j][k] = 1;
                        mp[i][j][k] = 1;
                    }
                    // 数据为 . 时，地图数组改为 1
                    else if (str[k - 1] == '.')
                    {
                        mp[i][j][k] = 1;
                    }
                    // 数据为 E 时，初始化终点
                    else if (str[k - 1] == 'E')
                    {
                        ende.x = i, ende.y = j, ende.z = k;
                        ende.sum = inf;
                        mp[i][j][k] = 1;
                    }
                }
            }
        }
        bfs();
        // 当 到达终点的时间 sum 为 无穷大 inf 时,输出 Trapped! , 否则输出 花费时间
        if (ende.sum == inf)
            printf("Trapped!\n");
        else
            printf("Escaped in %d minute(s).\n", ende.sum);
    }
    return 0;
}