[P1363] 幻想迷宫

题目链接


很好的一道搜索题,应该是利用了离散化的思想我好蒟蒻呀

地图是根据给定的图无限的拼接的。

所以说暴力建图是不可取的。

其实不难看出,在跨越两张图时。我们就可以看做这个点时空穿梭一般。从底下回来了。

所以只用在原图上跑dfs觉可以了。

那怎么判断是否在同一张图内被遍历了呢?
又这么判断同一个点在不同的图中是否被遍历了呢?

我们可以将他最近被遍历的原坐标(在无限的地图中的坐标)记录下来

如果一个点在一次被遍历时,如果这个点上一次被遍历到时的原坐标不等于现在的坐标。那么就找到了解

很好的题
#include<iostream> 
#include<cstdio>
#include<cstring>
using namespace std;
bool map[1600][1600];
bool found;
int vis[1600][1600][2];
bool used[1600][1600];
int n,m;
int dx[4]={0,0,-1,1};
int dy[4]={-1,1,0,0};
int turn[2]={1,0}; 
void dfs(int x,int y,int rx,int ry)
{
    if(used[x][y]&&(vis[x][y][0]!=rx||vis[x][y][1]!=ry))
    {
        found=true;
        return ;
    }
    if(used[x][y]&&vis[x][y][0]==rx&&vis[x][y][1]==ry)
        return ;
    used[x][y]=true;
    vis[x][y][0]=rx;
    vis[x][y][1]=ry;
    int x1,y1,x2,y2;
    for(int i=0;i<=3;i++)
    {
        x1=x+dx[i];
        x2=rx+dx[i];
        y1=y+dy[i];
        y2=ry+dy[i];
        if(x1>n)    x1-=n;
        if(x1<1)    x1+=n;
        if(y1>m)    y1-=m;
        if(y1<1)    y1+=m;
        if(map[x1][y1])
            dfs(x1,y1,x2,y2);
        if(found)
            return ;
    }
}
int main()
{
    cin.sync_with_stdio(false);
    char in;
    int begin,end;
    while(cin>>n>>m)
    {
        memset(map,0,sizeof(map));
        memset(vis,0,sizeof(vis)); 
        memset(used,0,sizeof(used));
        for(int i=1;i<=n;i++)
            for(int j=1;j<=m;j++)
            {
                cin>>in;
                switch(in)
                {
                    case 'S':begin=i;end=j;map[i][j]=true;break;
                    case '.':map[i][j]=true;break;
                    case '#':map[i][j]=false;break;
                }
            }
        dfs(begin,end,begin,end);
        if(found)
            cout<<"Yes"<<endl;
        else
            cout<<"No"<<endl;
        found=false;
    }
}

转载于:https://www.cnblogs.com/Lance1ot/p/8575944.html

在解决P1141 01迷宫问题时,通常采用深度优先搜索(DFS)或广度优先搜索(BFS)来实现。这类问题的核心在于如何找到从起点到终点的路径,其中迷宫中的`0`表示可以通过的路径,而`1`则表示障碍物。 ### 问题描述 P1141 01迷宫问题通常给出一个二维网格,每个格子包含`0`或`1`,要求从起点出发,找到到达终点的最短路径。通常,起点为`(0,0)`,终点为`(n-1,m-1)`,其中`n`和`m`分别为迷宫的行数和列数。 ### 解决思路 1. **BFS方法**:适用于寻找最短路径问题,因为BFS会逐层扩展,确保第一次到达终点时路径最短。 2. **DFS方法**:虽然可以找到路径,但不一定是最短路径,适用于不需要最短路径的情况。 3. **标记访问**:为了避免重复访问,需要维护一个访问标记数组。 4. **方向控制**:通常有四个方向可以移动:上、下、左、右。 ### BFS实现代码示例 以下是一个使用BFS解决P1141 01迷宫问题的Python实现: ```python from collections import deque def solve_maze(maze): n, m = len(maze), len(maze[0]) visited = [[False] * m for _ in range(n)] directions = [(-1, 0), (1, 0), (0, -1), (0, 1)] # 上、下、左、右 queue = deque() queue.append((0, 0, 0)) # 起点(0,0),步数0 visited[0][0] = True while queue: x, y, steps = queue.popleft() if x == n - 1 and y == m - 1: return steps # 找到终点,返回步数 for dx, dy in directions: nx, ny = x + dx, y + dy if 0 <= nx < n and 0 <= ny < m and maze[nx][ny] == 0 and not visited[nx][ny]: visited[nx][ny] = True queue.append((nx, ny, steps + 1)) return -1 # 无法到达终点 # 示例迷宫 maze = [ [0, 1, 0, 0, 0], [0, 1, 0, 1, 0], [0, 0, 0, 1, 0], [0, 1, 1, 1, 0], [0, 0, 0, 0, 0] ] print(solve_maze(maze)) # 输出最短路径的步数 ``` ### 代码解析 1. **初始化**:使用`deque`队列存储待访问的节点,起点为`(0, 0)`,初始步数为`0`。 2. **BFS循环**:从队列中取出当前节点,检查是否到达终点。若未到达终点,则向四个方向扩展,将未访问过的合法节点加入队列。 3. **终止条件**:若队列为空且未找到终点,则返回`-1`,表示无法到达终点。 ### 复杂度分析 - **时间复杂度**:`O(n*m)`,其中`n`和`m`分别为迷宫的行数和列数,每个节点最多访问一次。 - **空间复杂度**:`O(n*m)`,主要为队列和访问标记数组的空间。 ### 优化点 - 可以通过提前终止搜索来优化,一旦找到终点即可返回结果。 - 如果迷宫非常大,可以考虑使用双向BFS进一步优化。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值