記錄 簡單 return front include names 是否 con span

題目

題目大意：
這個題目就是大小不超過9*9的迷宮，給你起點終點和起點的方向，讓你進行移動
移動特別之處是不一定上下左右都可以，只有根據方向確定可以走的方向。
思路：
需要寫一個讀入函數，這個需要讀入起點，終點，方向（簡單），還有就是接下來幾行的不同位置
可以轉的方向，可以寫幾個函數，根據函數來判斷方向，最後轉換成數字，用bool類型數組0，1分別代表
可以或不可以。
之後要寫一個bfs，這個比較簡單，就是和普通差不多，但是之後要輸出路線，所以
要有兩個數組，一個用來存儲路程，一個用來存儲路線。
具體一點的bfs，就是先把初始位置放進去，寫清楚距離，之後進去while，while裏面要有一個判斷
是否到了終點，之後就用walk函數進行走路，然後判斷這一步是否合法，合法就走下一步，不過，走下一步之前，記住兩個點
第一個就是去記錄距離，第二個就是記錄路線。
最後有一個輸出函數，用vector 總的來說，這也是一個最短路問題，和robot有點像，就是每個位置不一定每個方向都是對的。

#include <stdio.h>
#include 
 
<stdlib.h>
#include <string.h>
#include <queue>
#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;
string name;
int x1,x2,y1,y2,dir,x,y;
int dx[4]={0,1,0,-1};
int dy[4]={1,0,-1,0};
const char *dirs="ESWN";
const char *turns="FLR";
const int
 
 maxn=100;
bool has_edge[maxn][maxn][10][10];
int d[maxn][maxn][4];

int dir_id(char c)
{
    return (strchr(dirs,c)-dirs);
}
int turn_id(char c)
{
    return (strchr(turns,c)-turns);
}

struct node
{
    int x,y,dir;
    node(int x=0,int y=0,int dir=0):x(x),y(y),dir(dir){}
}b[maxn][maxn][4];

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.x+dx[dir],u.y+dy[dir],dir);
}

bool scan()
{
    memset(has_edge,0,sizeof(has_edge));
    cin>>name;
    if(name=="END") return false;
    char s[100];
    cin>>x>>y>>s>>x2>>y2;

    dir=dir_id(s[0]);
    x1=x+dx[dir];
    y1=y+dy[dir];
    int r,c;
    while(cin>>r)
    {
        if(r==0) break;
        cin>>c;
        char s1[100];
        while(cin>>s1)
        {
            if(s1[0]==‘*‘) break;
            int l=strlen(s1);
            for(int i=1;i<l;i++)
            {
                has_edge[r][c][dir_id(s1[0])][turn_id(s1[i])]=1;
               // printf("has_edge[%d][%d][%d][%d]=1;\n",r,c,dir_id(s1[0]),turn_id(s1[i]));
            }
        }
    }
    cout<<name<<endl;
    return true;
}

bool judge(int r, int c)
{
    return r >=1 && r <= 9 && c >= 1 && c <= 9;//迷宮從1開始
}

void print_ans(node exa)
{
    vector<node>nodes;
    while(true)
    {
        nodes.push_back(exa);
        if(d[exa.x][exa.y][exa.dir]==0) break;
        exa=b[exa.x][exa.y][exa.dir];
    }
    nodes.push_back(node(x,y,dir));
    int cnt=0;
    for(int i=nodes.size()-1;i>=0;i--)
    {
        if(cnt%10==0) printf(" ");
        cnt++;
        printf(" (%d,%d)",nodes[i].x,nodes[i].y);
        if(cnt%10==0) printf("\n");
    }
    if(cnt%10!=0) printf("\n");
}

void bfs()
{
    queue<node>que;
    node exa=node(x1,y1,dir);
    memset(d,-1,sizeof(d));
    d[exa.x][exa.y][exa.dir]=0;
    que.push(exa);
    while(!que.empty())
    {
        node exa=que.front();
        //printf("%d %d %d\n",exa.x,exa.y,exa.dir);
        que.pop();
        if(exa.x==x2&&exa.y==y2)
        {
            print_ans(exa);
            return ;
        }
        for(int i=0;i<3;i++)
        {
            node v=walk(exa,i);
//            printf("www %d %d %d %d\n",v.x,v.y,v.dir,i);
//            printf("d[%d][%d][%d]=%d\n",v.x,v.y,v.dir,d[v.x][v.y][v.dir]);
            if(has_edge[exa.x][exa.y][exa.dir][i]&&judge(v.x,v.y)&&d[v.x][v.y][v.dir]<0)
            {
                d[v.x][v.y][v.dir]=d[exa.x][exa.y][exa.dir]+1;
                b[v.x][v.y][v.dir]=exa;
                //printf("%d %d %d\n",v.x,v.y,v.dir);
                que.push(v);
            }
        }
    }
    printf("  No Solution Possible\n");
}

int main()
{
    while(scan())
    {

        bfs();
    }
    return 0;
}

J - Abbott's Revenge 搜索 寒假訓練