816 - Abbott's Revenge（BFS）

最新推荐文章于 2021-12-08 11:30:39 发布

AC_Arthur

最新推荐文章于 2021-12-08 11:30:39 发布

阅读量707

点赞数

CC 4.0 BY-SA版权

分类专栏： uva解题报告文章标签： acm uva

本文链接：https://blog.youkuaiyun.com/weizhuwyzc000/article/details/43940237

uva解题报告专栏收录该内容

264 篇文章

订阅专栏

本文介绍了一道关于宽度优先搜索(BFS)的编程题，并通过代码实现了该算法。通过对题目进行解析，介绍了BFS的基本概念及其实现过程。作者还计划通过更多的练习来加深对BFS的理解。

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

第一道BFS题，对BFS有了个初步的了解。初学数据结构，只做紫书上的题还不够，打算等下去别的OJ上自主完成一些简单的BFS题来强化一下。

#include<bits/stdc++.h>
using namespace std;
const char* dirs = "NESW";
const char* turns = "FLR";
int r0,c0,dir,r1,c1,r2,c2,has_edge[19][19][10][10],d[19][19][10];
struct node {
    int r,c,dir;
    node (int r=0,int c=0,int dir=0):r(r),c(c),dir(dir) {}
}p[19][19][10];
int dir_id(char c) { return strchr(dirs,c) - dirs; }       
int turn_id(char c) { return strchr(turns,c)-turns; }      
const int dr[]={-1,0,1,0}; 
const int dc[]={0,1,0,-1};
node walk(const node& u,int turn ){
    int dir = u.dir;
    if(turn==1) dir = (dir+3)%4;
    if(turn==2) dir = (dir+1)%4;
    return node(u.r+dr[dir],u.c+dc[dir],dir);
}
void print_ans(node u){
    vector<node> nodes;
    for(;;){
        nodes.push_back(u);
        if(d[u.r][u.c][u.dir]==0) break;
        u=p[u.r][u.c][u.dir];
    }
    nodes.push_back(node(r0,c0,dir));
    int cnt=0;
    for(int i=nodes.size()-1;i>=0;i--) {
        if(cnt%10==0) printf(" ");
        printf(" (%d,%d)",nodes[i].r,nodes[i].c);
        if(++cnt%10==0) printf("\n");
    }
    if(nodes.size()%10!=0) printf("\n");
}
void solve(){
    queue<node> q;
    memset(d,-1,sizeof(d));
    node u(r1,c1,dir);
    d[u.r][u.c][u.dir] = 0;
    q.push(u);
    while(!q.empty()) {                              //bfs核心代码，通过队列的先进先出原则，依次搜索同一层的节点
        node u=q.front(); q.pop();
        if(u.r==r2&&u.c==c2) { print_ans(u);return ; }
        for(int i=0;i<3;i++) {
            node v=walk(u,i);
            if(has_edge[u.r][u.c][u.dir][i]&&d[v.r][v.c][v.dir]<0) { //限制条件，1.这个方向可以走。 2.这个位置、方向没有走过。
                d[v.r][v.c][v.dir] = d[u.r][u.c][u.dir] +1;
                p[v.r][v.c][v.dir] = u;
                q.push(v);
            }
        }
    }
    printf("  No Solution Possible\n");
}
int main(){
    string buf;
    while(cin>>buf) {
        if(buf=="END") break;
        char s[10]; cin>>r0>>c0>>s>>r2>>c2;
        dir=dir_id(s[0]);
        r1=dr[dir]+r0; c1=dc[dir]+c0;
        int r,c;
        memset(has_edge,0,sizeof(has_edge));
        while(cin>>r&&r) {
            cin>>c; string ss;
            while(cin>>ss){
                if(ss=="*") break;
                for(int i=1;i<ss.size();i++)
                has_edge[r][c][dir_id(ss[0])][turn_id(ss[i])]=1;
            }
        }
        cout<<buf<<'\n';
        solve();
    }
    return 0;
}