Abbott的复仇(ACM/ICPC World Finals)-刘汝佳紫书

题目连接

题意分析:

简单来说这是一道走迷宫的题目,但是不一样的地方是这道题多了一个"朝向问题",每当以不同"朝向"进入一个点,它的转向也是不同的!比如1 2 WLF,代表第一行第一列,朝向西进入该点,在该点可以左转,或者直走一步到下一个点,所以每次的"转向"不同决定进入下一个点的"朝向"不同!

首先输入起点的行与列,还有离开起点时的朝向,和终点的行与列。所以在起点是不能转向的,只能直走到下一个点。

解题思路:

这道题的整体思路就是bfs找最短路径,但是需要好多细节补充,因为它带有"朝向",和"转向"这两个状态,以及如何表示"朝向"和"转向"!

这道题有一个walk方法,这个方法可以算出在这个点的转向---->
下一个点的行与列---->从哪个方向进入下一个点。

传入该点的node(node中包含行,列,从哪个方向进入该点),以及turn转向(直走,左转,右转)。NESW代表北东南西,他们的index分别为0,1,2,3,N向左转后为W,E向左转后为N,S向左转后为E,我们可以发现就是index-1但是N的index为0所以我们采用(dir+3)%4的方式求出新的dir。同理向右转为(dir+1)%4,直走dir不改变!

node walk(const node& u,int turn)
{
    int dir=u.dir;
    //直走dir不变
    if(turn==1)dir=(dir+3)%4;//向左转
    if(turn==2)dir=(dir+1)%4;//向右转
    //计算walk后的行与列
    int new_r=u.r+dr[dir];
    int new_c=u.c+dc[dir];
    return node(new_r,new_c,dir);//返回一个新的node
}

这道题的读入也是挺麻烦大家慢慢看!注释写的很详细!

完整代码:

#include <bits/stdc++.h>

using namespace std;
const int maxn=20;
string maze_name;
int r0,c0,r1,c1,dir,r2,c2;//起点、起点一下步、终点

const char* dirs="NESW";//朝向
const char* turns="FLR";//转向
//每个点的状态(坐标+朝向)这个朝向是即将,向下一步走时的朝向
struct node
{
    int r,c,dir;
    node() {}
    node(int r,int c,int dir):r(r),c(c),dir(dir) {}
} p[maxn][maxn][maxn]; //p数组存储(r,c,dir)的父亲结点id,为了方便打印路径!
//计算char c在dirs中的下标位置
int dir_id(char c)
{
    return strchr(dirs,c)-dirs;//strchr()返回值为指针!
}
int turn_id(char c)
{
    return strchr(turns,c)-turns;
}

const int dr[]= {-1,0,1,0}; //向N,E,S,E走,行列的变化
const int dc[]= {0,1,0,-1};
//(r,c,dir,turn)
int has_edge[maxn][maxn][4][3];//has_edge表示r,c,在dir方向是否能向某个方向转
int d[maxn][maxn][maxn];//到达(r,c,dir)点的最小值

node walk(const node& u,int turn)
{
    int dir=u.dir;
    //直走dir不变
    if(turn==1)dir=(dir+3)%4;//向左转
    if(turn==2)dir=(dir+1)%4;//向右转
    //计算walk后的行与列
    int new_r=u.r+dr[dir];
    int new_c=u.c+dc[dir];
    return node(new_r,new_c,dir);//返回一个新的node
}
//inside判断是否越界
bool inside(int r,int c)
{
    return r>=1&&r<=9&&c>=1&&c<=9?true:false;
}
//打印路径
void print_ans(node u)
{
    //从终点-->起点
    vector<node> M;
    while(1)
    {
        M.push_back(u);
        if(d[u.r][u.c][u.dir]==0)break;//找到起点结束添加
        u=p[u.r][u.c][u.dir];
    }
    M.push_back(node(r0,c0,dir));//把起点添加,注意之前的第一个点是(r1,c1,dir),
    cout<<maze_name<<endl;
    int cnt=0;
    for (int i = M.size() - 1; i >= 0; i--)
    {
        if (cnt % 10 == 0) cout << " ";
        cout << " (" << M[i].r << "," << M[i].c << ")";
        if (++cnt % 10 == 0) cout << endl;
    }
    if(M.size()%10!=0)printf("\n");
}
void bfs()
{
    queue<node> q;
    memset(d,-1,sizeof(d));
    q.push(node(r1,c1,dir));
    d[r1][c1][dir]=0;
    while(!q.empty())
    {
        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]&&inside(v.r,v.c)&&d[v.r][v.c][v.dir]<0)
            {
                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);
            }
        }
    }
    cout << maze_name << endl;
    cout << "  No Solution Possible" << endl;
}

//读一个点的朝向、以及可以的转向
void read_edge()
{
    memset(has_edge,0,sizeof(has_edge));
    int pr,pc,pdir,pturn;
    string temp;
    while(cin>>pr)
    {
        if(pr==0)break;
        cin>>pc;
        while(cin>>temp)
        {
            if(temp=="*")break;
            pdir=dir_id(temp[0]);
            for(int i=1; i<temp.length(); i++)
            {
                pturn=turn_id(temp[i]);
                has_edge[pr][pc][pdir][pturn]=1;
            }
        }
    }
}
//读起始点、起始点朝向、终点
bool read_list()
{
    cin>>maze_name;
    if(maze_name=="END")return false;
    char dir0;
    cin>>r0>>c0>>dir0>>r2>>c2;
    dir=dir_id(dir0);//转换为int型dir
    r1=r0+dr[dir];
    c1=c0+dc[dir];
    read_edge();

    return true;
}

int main()
{
    while(read_list())
    {
        bfs();
    }
    return 0;
}

感谢观看,如果对你有帮助多多点赞支持!