G-POJ-3984 迷宫问题

简介: POJ-3984 Time Limit: 1000MS Memory Limit: 65536KDescription 定义一个二维数组: in...

POJ-3984

Description

定义一个二维数组:

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表示可以走的路,只能横着走或竖着走,不能斜着走,要求编程序找出从左上角到右下角的最短路线。

Input
一个5 × 5的二维数组,表示一个迷宫。数据保证有唯一解。

Output
左上角到右下角的最短路径,格式如样例所示。

Sample Input
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
Sample Output
(0, 0)
(1, 0)
(2, 0)
(2, 1)
(2, 2)
(2, 3)
(2, 4)
(3, 4)
(4, 4)

BFS、DFS都可以

1.BFS:用树存路径压入栈,一次AC看代码吧:

//AC:736K   0MS 
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<stack>
#include<queue>
using namespace std;
struct map{
    int x,y;
    int parent;
    int step;
}path[1000],S;
bool vis[5][5];
void BFS(int s[5][5]){
    map now,next;
    memset(vis,false,sizeof(vis));
    now.x=0,now.y=0,now.step=0;
    path[0].x=0,path[0].y=0;
    int n=1,m=-1;
    vis[0][0]=true;
    queue<map>Q;
    stack<map>N;
    Q.push(now);
    while(!Q.empty()){
        now=Q.front();
        Q.pop();
        m++;
        if(now.x==4&&now.y==4){
            N.push(path[m]);
            for(;;){
                m=path[m].parent;
                N.push(path[m]);
                if(m==0)
                    break;
            }
            for(int i=0;i<=now.step;i++){
                S=N.top();
                N.pop();
                printf("(%d, %d)\n",S.x,S.y);
            }
            return;
        }
        for(int j=1;j<=4;j++){
            if(j==1){
                next.x=now.x;
                next.y=now.y+1;
                next.step=now.step+1;
                if(!vis[next.x][next.y]&&0<=next.x&&next.x<=4&&0<=next.y&&next.y<=4&&s[next.x][next.y]!=1){
                    Q.push(next);
                    path[n].x=next.x;
                    path[n].y=next.y;
                    path[n].parent=m;
                    n++;
                }
            }
            if(j==2){
                next.x=now.x+1;
                next.y=now.y;
                next.step=now.step+1;
                if(!vis[next.x][next.y]&&0<=next.x&&next.x<=4&&0<=next.y&&next.y<=4&&s[next.x][next.y]!=1){
                    Q.push(next);
                    path[n].x=next.x;
                    path[n].y=next.y;
                    path[n].parent=m;
                    n++;
                }
            }
            if(j==3){
                next.x=now.x-1;
                next.y=now.y;
                next.step=now.step+1;
                if(!vis[next.x][next.y]&&0<=next.x&&next.x<=4&&0<=next.y&&next.y<=4&&s[next.x][next.y]!=1){
                    Q.push(next);
                    path[n].x=next.x;
                    path[n].y=next.y;
                    path[n].parent=m;
                    n++;
                }
            }
            if(j==4){
                next.x=now.x;
                next.y=now.y-1;
                next.step=now.step+1;
                if(!vis[next.x][next.y]&&0<=next.x&&next.x<=4&&0<=next.y&&next.y<=4&&s[next.x][next.y]!=1){
                    Q.push(next);
                    path[n].x=next.x;
                    path[n].y=next.y;
                    path[n].parent=m;
                    n++;
                }
            }
        }
    }

}
int main(){
    int maze[5][5];
    for(int i=0;i<5;i++)
        for(int j=0;j<5;j++)
            scanf("%d",&maze[i][j]);
    BFS(maze);
    return 0;
}

2.DFS,这个写的时候由于每种情况分开写bug一大堆:

//AC: 708K  0MS
#include<cstdio>
#include<iostream>
#include<cstring>
#include<stack>
using namespace std;
bool vis[5][5];
struct{
    int x,y;
}path[1000];
int n=0;
void DFS(int s[5][5],int x,int y,int step){
    vis[path[step].x][path[step].y]=true;
    for(int i=1;i<=4;i++){
        if(i==1){
            path[step+1].x=x+1;
            path[step+1].y=y;
            if(0<=path[step+1].x&&path[step+1].x<=4&&0<=path[step+1].y&&path[step+1].y<=4&&s[path[step+1].x][path[step+1].y]!=1&&!vis[path[step+1].x][path[step+1].y]){
                if(path[step+1].x==4&&path[step+1].y==4){
                    n=step;
                }
                if(n)   return;
                else{
                    DFS(s,path[step+1].x,path[step+1].y,step+1);
                    if(n)   break;
                    vis[path[step+1].x][path[step+1].y]=false;
                }
            }
        }
        if(i==2){
            path[step+1].x=x;
            path[step+1].y=y+1;
            if(0<=path[step+1].x&&path[step+1].x<=4&&0<=path[step+1].y&&path[step+1].y<=4&&s[path[step+1].x][path[step+1].y]!=1&&!vis[path[step+1].x][path[step+1].y]){
                if(path[step+1].x==4&&path[step+1].y==4){
                    n=step+1;
                }
                if(n)   return;
                else{
                    DFS(s,path[step+1].x,path[step+1].y,step+1);
                    if(n)   break;
                    vis[path[step+1].x][path[step+1].y]=false;
                }
            }
        }
        if(i==3){
            path[step+1].x=x-1;
            path[step+1].y=y;
            if(0<=path[step+1].x&&path[step+1].x<=4&&0<=path[step+1].y&&path[step+1].y<=4&&s[path[step+1].x][path[step+1].y]!=1&&!vis[path[step+1].x][path[step+1].y]){
                if(path[step+1].x==4&&path[step+1].y==4){
                    n=step+1;
                }
                if(n)   return;
                else{
                    DFS(s,path[step+1].x,path[step+1].y,step+1);
                    if(n)   break;
                    vis[path[step+1].x][path[step+1].y]=false;
                }
            }
        }
        if(i==4){
            path[step+1].x=x;
            path[step+1].y=y-1;
            if(0<=path[step+1].x&&path[step+1].x<=4&&0<=path[step+1].y&&path[step+1].y<=4&&s[path[step+1].x][path[step+1].y]!=1&&!vis[path[step+1].x][path[step+1].y]){
                if(path[step+1].x==4&&path[step+1].y==4){
                    n=step+1;
                }
                if(n)   return;
                else{
                    DFS(s,path[step+1].x,path[step+1].y,step+1);
                    if(n)   break;
                    vis[path[step+1].x][path[step+1].y]=false;
                }
            }
        }
    }
}
int main(){
    int maze[5][5];
    memset(vis,false,sizeof(vis));
    for(int i=0;i<5;i++)
        for(int j=0;j<5;j++)
            scanf("%d",&maze[i][j]);
    DFS(maze,0,0,0);
    for(int i=0;i<=n+1;i++)
        printf("(%d, %d)\n",path[i].x,path[i].y);
    return 0;
}
目录
相关文章
|
人工智能 JSON 前端开发
有关D2C工具的思考和分享, 提升前端研发效率
有关D2C工具的思考和分享, 提升前端研发效率
640 1
|
XML 编译器 Android开发
Kotlin DSL 实战:像 Compose 一样写代码
Kotlin DSL 实战:像 Compose 一样写代码
442 0
|
安全 Java 项目管理
云效常见问题之maven私有仓库迁移如何解决
云效(CloudEfficiency)是阿里云提供的一套软件研发效能平台,旨在通过工程效能、项目管理、质量保障等工具与服务,帮助企业提高软件研发的效率和质量。本合集是云效使用中可能遇到的一些常见问题及其答案的汇总。
421 0
|
机器学习/深度学习 监控 Ubuntu
perf性能分析工具使用分享
perf性能分析工具使用分享
2707 0
perf性能分析工具使用分享
|
5月前
|
人工智能 关系型数据库 MySQL
轻松搭建AI知识问答系统,阿里云PolarDB MCP深度实践
无论是PolarDB MySQL兼容MySQL语法的SQL执行功能,还是其特有的OLAP分析与AI能力,通过MCP协议向LLM开放接口后,显著降低了用户使用门槛,更为未来基于DB-Agent的智能体开发奠定了技术基础
|
10月前
|
计算机视觉 Perl
RT-DETR改进策略【Backbone/主干网络】| 替换骨干网络为CVPR-2024 PKINet 获取多尺度纹理特征,适应尺度变化大的目标
RT-DETR改进策略【Backbone/主干网络】| 替换骨干网络为CVPR-2024 PKINet 获取多尺度纹理特征,适应尺度变化大的目标
285 10
RT-DETR改进策略【Backbone/主干网络】| 替换骨干网络为CVPR-2024 PKINet 获取多尺度纹理特征,适应尺度变化大的目标
|
11月前
|
机器学习/深度学习 编解码 人工智能
STAR:南京大学联合字节开源视频超分辨率增强生成框架,视频清晰度一键提升,支持从低分辨率视频生成高分辨率视频
STAR 是由南京大学、字节跳动和西南大学联合推出的视频超分辨率框架,能够将低分辨率视频提升为高分辨率,同时保持细节清晰度和时间一致性。
2238 13
STAR:南京大学联合字节开源视频超分辨率增强生成框架,视频清晰度一键提升,支持从低分辨率视频生成高分辨率视频
|
10月前
|
算法 测试技术 Swift
Kimi开源Moonlight-16B-A3B:基于Muon优化器的高效大模型,性能与训练效率双突破!
Kimi开源Moonlight-16B-A3B:基于Muon优化器的高效大模型,性能与训练效率双突破!
368 5
|
开发框架 JSON 缓存
基于SqlSugar的开发框架循序渐进介绍(22)-- Vue3+TypeScript的前端工作流模块中实现统一的表单编辑和表单详情查看处理
基于SqlSugar的开发框架循序渐进介绍(22)-- Vue3+TypeScript的前端工作流模块中实现统一的表单编辑和表单详情查看处理
|
Oracle Java 关系型数据库
2022 年超详细过程步骤讲解 CentOS 7 安装jdk1.8
这篇文章提供了在CentOS 7系统上安装JDK 1.8的详细步骤,包括卸载系统自带的JDK、下载Oracle官网的JDK安装包、上传至虚拟机、解压安装包、配置环境变量,并验证安装是否成功。
2022 年超详细过程步骤讲解 CentOS 7 安装jdk1.8