CSU 1259 跳跳 (bfs)

最新推荐文章于 2016-11-28 22:57:39 发布

原创最新推荐文章于 2016-11-28 22:57:39 发布 · 745 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

收录于

bfs

本文介绍了一种解决特殊迷宫最短路径问题的算法，该迷宫中包含可瞬移的数字地板，通过广度优先搜索实现路径寻找。文章详细展示了如何处理地图数据，并在遇到特定数字时进行额外的步骤更新。

链接：CSU 1259

Description

一个每块地板标记着0~9某个数字的迷宫，其中标记1的地板不可以走，标记2~9的地板可以不花时间地跳到任意相同数字的位置，也可以和标记0的地板一样向前后左右任意方向花1个单位时间移动1的距离。给出起点和终点，求起点到终点的最短时间。

Input

每组数据第一行一个n，表示尺寸，2 <= n <= 100。

接下来n行每行n个0~9的字符，或S表示起点，E表示终点，S和E的运动规则与0相同。整个地图只有一个S和一个E。

Output

每组数据输出一个数，占一行，表示起点到终点可以花费的最短时间。

如果无法到达重点，输出"Oh No!"

Sample Input

Sample Output

4
Oh No!

这个题要注意的是，走到2-9后，需要接着把所有与之相同的数字所要的步数更新

之前因为这个一直错、、、

#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
struct stu
{
    int i,j;
};
int a[101][101],m;
char s[101][101];
queue<struct stu> q;
void xtd(int i,int j)
{
    struct stu n;
    int i1,j1;
    if(s[i][j]>='2'&&s[i][j]<='9')
        for(i1=0;i1<m;i1++)
            for(j1=0;j1<m;j1++)
                if(s[i1][j1]==s[i][j]&&!a[i1][j1]){
                    n.i=i1;
                    n.j=j1;
                    q.push(n);
                    a[i1][j1]=a[i][j];
                }
}
int bfs(struct stu n)
{
    int i,j,flag=0;
    q.push(n);
    a[n.i][n.j]=1;
    while(!q.empty()){
        n=q.front();
        i=n.i;
        j=n.j;
        q.pop();
        if(s[i][j]=='E'){
            flag=1;
            break;
        }
        if(s[i][j]!='1'){
            if(i-1>=0&&s[i-1][j]!='1'&&!a[i-1][j]){
                n.i=i-1;
                n.j=j;
                q.push(n);
                a[i-1][j]=a[i][j]+1;
                xtd(i-1,j);
            }
            if(i+1<m&&s[i+1][j]!='1'&&!a[i+1][j]){
                n.i=i+1;
                n.j=j;
                q.push(n);
                a[i+1][j]=a[i][j]+1;
                xtd(i+1,j);
            }
            if(j-1>=0&&s[i][j-1]!='1'&&!a[i][j-1]){
                n.i=i;
                n.j=j-1;
                q.push(n);
                a[i][j-1]=a[i][j]+1;
                xtd(i,j-1);
            }
            if(j+1<m&&s[i][j+1]!='1'&&!a[i][j+1]){
                n.i=i;
                n.j=j+1;
                q.push(n);
                a[i][j+1]=a[i][j]+1;
                xtd(i,j+1);
            }
        }
    }
    return flag;
}
int main()
{
    int i,j,t;
    struct stu n,k;
    while(scanf("%d",&m)!=EOF){
        getchar();
        for(i=0;i<m;i++){
            for(j=0;j<m;j++){
                scanf("%c",&s[i][j]);
                if(s[i][j]=='S'){
                    n.i=i;
                    n.j=j;
                }
                else if(s[i][j]=='E'){
                    k.i=i;
                    k.j=j;
                }
            }
            getchar();
        }
        memset(a,0,sizeof(a));
        while(!q.empty())
            q.pop();
        t=bfs(n);
        if(t)
            printf("%d\n",a[k.i][k.j]-1);
        else
            printf("Oh No!\n");
    }
    return 0;
}

标签

#bfs