`

搜索问题poj 2251BFS问题

 
阅读更多

题目大意:这题是一个三维的迷宫题目,其中用'.'表示空地,'#'表示障碍物,'S'表示起点,'E'表示终点,求从起点到终点的最小移动次数,解法和二维的类似,只是在行动时除了东南西北移动外还多了上下。对于题目给出数据的含义就是输入l,r,c,分别代表迷宫有l层,每层长宽分别是c,r。

解题思路:我认为重要的地方一是在于初期的建模,初始想想有一个长宽高都为30的大3d迷宫,根据输入的l,r,c来决定使用的这个大迷宫的空间到底是多少。二是后面对行走路径的判断(即如何判断哪些路是可以走的),某个点可以走的条件——这个点以前没有走过;这个点没有超过迷宫的范围;这个点对应的字符时‘.’或者是'E'(特别是对E的判断,我就忘掉了)。最后,在做题过程中如果用到了队列这个数据结构,在用完之后一定要记得清空,在这个问题上让我贡献了n个WA,还是太水,牢记~~

这道题比较坑爹的一个地方是网上很多资料都将其总结到DFS搜索中,这也太不靠谱了,尼玛非常费劲。

对于数据以可以这样移动
(1,1,1)->(1,1,2)->(1,1,3)->(1,1,4)->(1,1,5)->(1,2,5)
->(1,3,5)->(1,3,4)->(1,4,4)->(2,4,4)->(2,4,5)->(3,4,,5)
共11步就可以到达终点 对于数据二明显不能到达,则输出Trapped
这题用BFS解,每次去队首元素,如果是终点则输出结果移动的次数,否则,从该点开始分别向东南西北上下移动(如果可以走的话)并继续搜,如果到队列为空还没搜到解法,则说明无解。

 

代码如下:

#include <iostream>
#include <queue>
using namespace std;


char ddd[31][31][31];
int flag;
int l,r,c;


struct xyz
{
    int x;
    int y;
    int z;
}s,e;


struct cd
{
    int vis;
    int num;
    int x;
    int y;
    int z;
}cddd[31][31][31];


void init()
{
    for(int i = 0;i < 31;i++)
        for(int j = 0;j < 31;j++)
            for(int k = 0;k < 31;k++)
            {
                cddd[i][j][k].num = 0;
                cddd[i][j][k].vis = 0;
                cddd[i][j][k].x = i;
                cddd[i][j][k].y = j;
                cddd[i][j][k].z = k;
            }
    flag = 0;
}


int main()
{
    int i,j,k;
    queue <cd> q;
    while(scanf("%d%d%d",&l,&r,&c)!= EOF&&l!=0&&r!=0&&c!=0)
    {
        init();
        for(i = 0;i < l;i++)
            for(j = 0;j < r;j++)
            {
             /*   scanf("%s",ddd[i][j]);*/
				cin>>ddd[i][j];
                for(k = 0;k < c;k++)
                {
                    if(ddd[i][j][k] == 'S')
                    {
                        s.x = i;
                        s.y = j;
                        s.z = k;
                    }
                    if(ddd[i][j][k] == 'E')
                    {
                        e.x = i;
                        e.y = j;
                        e.z = k;
                    }
                }
            }
        q.push(cddd[s.x][s.y][s.z]);
        cddd[s.x][s.y][s.z].vis = 1;
        while(!q.empty())
        {
            cd front = q.front();
            int cx = front.x;
            int cy = front.y;
            int cz = front.z;
            if(cddd[e.x][e.y][e.z].vis)
            {
                flag = 1;
                break;
            }
            q.pop();
            if(!cddd[cx + 1][cy][cz].vis && cx + 1 < l && ddd[cx + 1][cy][cz] == '.' || ddd[cx + 1][cy][cz] == 'E')//一定要记得某个点可以走那么这个点也有可能是"E"
            {
                q.push(cddd[cx + 1][cy][cz]);
                cddd[cx + 1][cy][cz].num += cddd[cx][cy][cz].num + 1;
                cddd[cx + 1][cy][cz].vis = 1;
            }
            if(!cddd[cx - 1][cy][cz].vis && cx - 1 >= 0 && ddd[cx - 1][cy][cz] == '.' || ddd[cx - 1][cy][cz] == 'E')
            {
                q.push(cddd[cx - 1][cy][cz]);
                cddd[cx - 1][cy][cz].num += cddd[cx][cy][cz].num + 1;
                cddd[cx - 1][cy][cz].vis = 1;
            }
            if(!cddd[cx][cy + 1][cz].vis && cy + 1 < r && ddd[cx][cy + 1][cz] == '.' || ddd[cx][cy + 1][cz] == 'E')
            {
                q.push(cddd[cx][cy + 1][cz]);
                cddd[cx][cy + 1][cz].num += cddd[cx][cy][cz].num + 1;
                cddd[cx][cy + 1][cz].vis = 1;
            }
            if(!cddd[cx][cy - 1][cz].vis && cy - 1 >= 0 && ddd[cx][cy - 1][cz] == '.' || ddd[cx][cy - 1][cz] == 'E')
            {
                q.push(cddd[cx][cy - 1][cz]);
                cddd[cx][cy - 1][cz].num += cddd[cx][cy][cz].num + 1;
                cddd[cx][cy - 1][cz].vis = 1;
            }
            if(!cddd[cx][cy][cz + 1].vis && cz + 1 < c && ddd[cx][cy][cz + 1] == '.' || ddd[cx][cy][cz + 1] == 'E')
            {
                q.push(cddd[cx][cy][cz + 1]);
                cddd[cx][cy][cz + 1].num += cddd[cx][cy][cz].num + 1;
                cddd[cx][cy][cz + 1].vis = 1;
            }
            if(!cddd[cx][cy][cz - 1].vis && cz - 1 >= 0 && ddd[cx][cy][cz - 1] == '.' || ddd[cx][cy][cz - 1] == 'E')
            {
                q.push(cddd[cx][cy][cz - 1]);
                cddd[cx][cy][cz - 1].num += cddd[cx][cy][cz].num + 1;
                cddd[cx][cy][cz - 1].vis = 1;
            }
        }
        while(!q.empty())     
			q.pop();//一定记得队列用完要清空!
        if(flag)
            printf("Escaped in %d minute(s).\n",cddd[e.x][e.y][e.z].num);
        else
            printf("Trapped!\n");
    }
    return 0;
}

 

关于搜索问题还有很多地方不明白,以后还得自行研究!!


 

 

 

分享到:
评论

相关推荐

    POJ2251-Dungeon Master

    【标签】"POJ 2251 Dungeon Master" 作为标签,便于将这个题目与其他POJ题目区分开,方便搜索和归类。Dungeon Master可能暗示题目背景与角色扮演游戏或者迷宫探索有关,需要利用编程技巧解决迷宫或战斗策略等游戏...

    POJ1426-Find The Multiple【BFS+同余模】

    【标题】"POJ1426-Find The Multiple【BFS+同余模】"是一道来源于北京大学在线编程平台POJ的算法题目,主要涉及到了广度优先搜索(BFS)与同余模运算的知识点。这道题目要求解决的是寻找一个整数的倍数问题,可能...

    NOI2002.rar_NOI 2002 dragon_poj bfs

    标题中的“NOI2002.rar_NOI 2002 dragon_poj bfs”提到了几个关键元素:NOI(全国青少年信息学奥林匹克),2002年赛事,dragon问题,以及poj_bfs。这表明我们即将讨论的是2002年全国青少年信息学奥林匹克竞赛中的...

    POJ3026-Borg Maze【BFS+Prim】

    在计算机科学领域,图论是解决问题的重要工具之一,而BFS(广度优先搜索)和Prim算法则是其中的两种经典算法。本篇文章将围绕北大POJ3026题目“Borg Maze”来探讨这两种算法在解决实际问题中的应用。 “Borg Maze”...

    POJ_3131.zip_POJ 八数码_poj

    描述中提到的“双向BFS解立体八数码问题”表明这个项目使用了广度优先搜索(BFS)算法来解决立体版的八数码问题。立体八数码是在二维八数码的基础上扩展的,增加了更多的维度,使得问题的复杂性增加,解决起来更具...

    北大POJ初级-简单搜索

    在实际编程实践中,理解并熟练运用简单搜索算法是基础,随着能力的提升,还会接触到更高级的搜索算法,如深度优先搜索(DFS)、广度优先搜索(BFS),以及二叉搜索树等更复杂的搜索结构。在POJ平台上不断挑战和解决...

    poj各种分类

    DFS和BFS不仅是图算法的核心,也是解决许多搜索问题的基础,如poj2488和poj3278所示。 #### 剪枝技术 在搜索过程中去除无效或低效的搜索路径,提高搜索效率,如poj2531和poj1416。 ### 五、动态规划 #### 背包...

    经典 的POJ 分类

    - POJ 2251:BFS的应用场景。 #### 其他搜索算法 - **题目示例**: - POJ 3278、POJ 1426:特殊搜索策略的应用。 - POJ 3126、POJ 3087:复杂搜索策略解决实际问题。 ### 动态规划 #### 一维动态规划 - **题目...

    acm训练计划(poj的题)

    - (poj1328, poj2109, poj2586):介绍各种搜索算法,如深度优先搜索(DFS)、广度优先搜索(BFS)等。 3. **排序与查找**: - 提供对排序和查找算法的理解与应用指导,包括快速排序、归并排序、二分查找等经典...

    POJ1753-Flip Game

    本篇文章将对这个问题进行深入解析,并提供两种不同的解决方案:一种基于广度优先搜索(BFS)和位运算,另一种基于深度优先搜索(DFS)和枚举。 一、问题概述 "Flip Game" 是一个二人博弈类问题,玩家轮流操作,...

    POJ 部分题解 解题报告

    5. **PKU 1010 搜索.txt**:搜索问题通常包括深度优先搜索(DFS)、广度优先搜索(BFS)或A*搜索算法。可能需要解决路径查找、迷宫求解等问题。 6. **POJ 3468 线段树--long long VS int.txt**:线段树是处理区间...

    LeetCode判断字符串是否循环-Leetcode:刷!

    背包问题 动态规划 POJ 3267 POJ 1260 POJ 1015 POJ 3176 POJ 1080 POJ 1159 POJ 2533 POJ 1836 Leetcode 70 Leetcode 309 搜索 DFS POJ 2488 POJ 3083 POJ 3009 POJ 1321 BFS POJ 3278 POJ 1426 POJ 3126 POJ 3414 ...

    POJ1011-Sticks

    它涉及了数据结构(如并查集)、搜索算法(如DFS或BFS)以及几何问题的处理,对于提升编程竞赛技巧非常有帮助。通过解决这个问题,程序员可以深入理解如何在实际问题中运用计算机科学的基本原理。

    POJ2531-Network Saboteur

    可能需要理解并应用深度优先搜索(DFS)或广度优先搜索(BFS)来解决网络问题。 2. **图的遍历**:DFS和BFS是解决图问题的常用方法,它们可以用来寻找特定路径或计算节点之间的最短路径。 3. **网络破坏策略**:...

    POJ3126-Prime Path

    【标签】"POJ 3126 Prime Path" 指明了问题的关键元素:POJ是一个在线编程平台,3126是这道题目的编号,Prime Path则揭示了问题的核心,即寻找素数路径。 【详细说明】在解决"Prime Path"这个问题时,我们需要掌握...

    POJ1039-Pipe

    POJ1039-Pipe可能需要应用到的算法包括但不限于深度优先搜索(DFS)、广度优先搜索(BFS)、动态规划、贪心算法或图的遍历算法。 4. **图论**:由于题目名为"Pipe",很可能涉及到图的结构,比如管道之间的连接可以...

    强大的poj分类

    常用的搜索算法有深度优先搜索(DFS)、广度优先搜索(BFS)、贪心算法、回溯算法等。 **重要性**:搜索算法是解决许多复杂问题的有效手段。例如,在游戏AI、路径规划等领域有着广泛的应用。 **示例题目**: - POJ...

    ACM-POJ 算法训练指南

    2. **搜索**:涉及广度优先搜索(BFS)和深度优先搜索(DFS)(poj1328, poj2109, poj2586),是解决图问题的关键。 3. **贪心算法**:通过局部最优选择来达到全局最优解的方法,如背包问题(poj3295)。 4. **动态...

    acm新手刷题攻略之poj

    - 搜索算法包括深度优先搜索(DFS)、广度优先搜索(BFS)等,适用于解决图遍历问题。 4. **模拟** - 推荐题目:[poj1068](https://vjudge.net/problem/POJ-1068)、[poj2632](https://vjudge.net/problem/POJ-2632)、...

    POJ 分类题目 txt文件

    搜索如深度优先搜索(DFS)、广度优先搜索(BFS),用于探索问题的所有可能解或最优解;贪心策略则是在每一步选择局部最优解,期望得到全局最优解。例如,题目poj1753和poj2965就属于排序相关的题目。 ### 2. 图论...

Global site tag (gtag.js) - Google Analytics