hrbust 2188 星际旅行_csdn星际旅行-优快云博客

本文介绍了一种解决星际旅行问题的算法，通过BFS搜索结合传送门（黑洞）的特性来计算从起点到终点的最短时间。文章提供了一个具体的实现案例，包括地图输入、黑洞位置记录及BFS遍历过程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

星际旅行

Time Limit: 1000 MS

Memory Limit: 32768 K

Total Submit: 113(45 users)

Total Accepted: 56(42 users)

Rating:

Special Judge: No

Description

小z在星际旅行中，他想从当前起始点到达目的地，他可以上下左右的移动，并且每移动一格需要花费一单位时间，

星际中有许多危险的地方不可以走，还有许多的黑洞，你可以不花费任何时间从一个黑洞瞬间到达其它任何一个黑洞，

请你帮助小z计算从当前起始点到目的地最少需要多少单位时间。

Input

第一行是一个整数T,代表T组测试数据。

对于每组测试数据，首先是两个整数n,m代表星际地图(1<=n<=100, 1<=m<=100)

接下来是一个n*m的地图。

'O' 代表黑洞。

'#' 代表不可以走的地方。

'.' 代表普通的空间。

'S' 代表起始点,有且只有一个。

'E' 代表目的地,有且只有一个。

Output

对于每组测试数据，如果小z可以到达目的地，则输出需要的最少时间，否则输出"impossible"。

Sample Input

3 4

SO..

....

..OE

3 3

#S#

###

E##

Sample Output

impossible

思路简单，存下所有传送门位置，bfs扫到传送门后将所有传送门VIS记录为1，继续搜索；

#include<bits/stdc++.h>
using namespace std;
char maps[102][102];
int black_hole[102 * 102][102];
int vis[102][102];
int n, m, x, y, num;
int Step[4][2] = {1, 0, 0, 1, -1, 0, 0, -1};
struct node
{
    int xx, yy, step;
} op, uv;
void bfs(int x, int y)
{
    memset(vis, 0, sizeof vis);
    queue<node>q;
    op.xx = x;
    op.yy = y;
    op.step = 0;
    q.push(op);
    vis[x][y] = 1;
    while(!q.empty())
    {
        op = q.front();
        if(maps[op.xx][op.yy] == 'E')
        {
            printf("%d\n",op.step);
            return;
        }
        q.pop();
        for(int i = 0; i < 4; i++)
        {
            uv.xx = op.xx + Step[i][0];
            uv.yy = op.yy + Step[i][1];
            if(uv.xx >=0 && uv.yy >= 0 && uv.xx < n && uv.yy < m && !vis[uv.xx][uv.yy] && maps[uv.xx][uv.yy] != '#')
            {
                if(maps[uv.xx][uv.yy] == '.' || maps[uv.xx][uv.yy] == 'E')
                {
                    vis[uv.xx][uv.yy] = 1;
                    uv.step = op.step + 1;
                    q.push(uv);
                }
                if(maps[uv.xx][uv.yy] == 'O')
                {
                    vis[uv.xx][uv.yy] = 1;
                    for(int j = 0; j < num; j++)
                    {
                        if(!vis[black_hole[j][0]][black_hole[j][1]])
                        {
                            uv.step = op.step + 1;
                            uv.xx = black_hole[j][0];
                            uv.yy = black_hole[j][1];
                            vis[black_hole[j][0]][black_hole[j][1]] = 1;
                            q.push(uv);
                        }
                    }
                }
            }
        }
    }
    printf("impossible\n");
    return;
}
int main()
{
    int N;
    scanf("%d", &N);
    while(N--)
    {
        memset(black_hole, 0, sizeof black_hole);
        scanf("%d%d", &n, &m);
        for(int i = 0; i < n; i ++)
            scanf("%s", maps[i]);
        num = 0;
        for(int i = 0; i < n; i ++)
        {
            for(int j = 0; j < m; j ++)
            {
                if(maps[i][j] == 'O')
                {
                    black_hole[num][0] = i;
                    black_hole[num][1] = j;
                    num ++;
                }
                if(maps[i][j] == 'S')
                {
                    x = i;
                    y = j;
                }
            }
        }
        bfs(x, y);
    }
}