【紫书】【重要】Abbott's Revenge UVA - 816 bfs 复杂模拟 带方向参数的迷宫

题意：一个迷宫，每个交叉路口有一路标，限制了你从某方向进入该路口所能进入的路口。

题解：1.对于方向的处理：将node多增加一维dir，通过一个const 字符数组 加 上dir_id函数 以及一个方向数组 快速完成从读取字母到模拟路口限制的转换。

　　　2.用一个四位数组记录某节点某方向是否能走，

　　    3.对于路径的记录，用node p[] 记录当前节点的前一个节点，然后将其中的元素push到一个vector里面再输出。

　　

坑：1.no possible input 多了个空格（紫书上没有前缀空格）

　　自己写的read_input,结果显示忘记了初始化，

　　第一步理解错误。

#define _CRT_SECURE_NO_WARNINGS
#include "stdio.h"
#include<stdio.h>
#include<algorithm>
#include<string>
#include<vector>
#include<list>
#include<set>
#include<iostream>
#include<string.h>
#include<queue>
#include<string>
#include<sstream>
using namespace std;
const int maxn = +;

const char* dirs = "NESW";
const char* turns = "FLR";
int dir_id(char c) { return strchr(dirs, c) - dirs; }
int turn_id(char c) { return strchr(turns, c) - turns; }

const int dr[] = { -,,, };
const int dc[] = { ,,,- };
//NESW
int r1, c1,r0,c0,r2,c2,dir,mxr,mxc;

struct node {
    int r, c, dir;
    node(int r = , int c = , int dir = ) :r(r), c(c), dir(dir) {}
};
node walk(const node& u, int turn) {
    int dir = u.dir;
    if (turn == )dir = (dir + ) % ;
    if (turn == ) dir = (dir + ) % ;
    return node(u.r + dr[dir], u.c + dc[dir], dir);
}
int d[maxn][maxn][maxn];
node p[maxn][maxn][maxn];
int has_edge[maxn][maxn][maxn][maxn];
bool inside(int r,int c) {
    return (r>=&&r<=&&c>=&&c<=);
}
void print_ans(node u) {
    vector<node> nodes;
    for (;;) {
        nodes.push_back(u);
        if (d[u.r][u.c][u.dir] == )break;
        u = p[u.r][u.c][u.dir];
    }
    nodes.push_back(node(r0, c0, dir));

    int cnt = ;
    for (int i = nodes.size() - ; i >= ; i--) {
        if (cnt %  == ) cout << ' ';
        printf(" (%d,%d)", nodes[i].r, nodes[i].c);
        if (++cnt %  == ) cout << endl;
    }
    if (nodes.size() %  != )cout << endl;
}
void solve() {
    queue<node>Q;
    memset(d, -, sizeof(d));
    node u(r1, c1, dir);
    d[u.r][u.c][u.dir]=;
    Q.push(u);
    while (!Q.empty()) {
        node u = Q.front(); Q.pop();
        if (u.r == r2&&u.c == c2) { print_ans(u); return; }
        for (int i = ; i < ; i++) {
            node v = walk(u, i);
            if (has_edge[u.r][u.c][u.dir][i] &&  d[v.r][v.c][v.dir] < &&inside(v.    r,v.c)) {
                d[v.r][v.c][v.dir] = d[u.r][u.c][u.dir] + ;
                p[v.r][v.c][v.dir] = u;
                Q.push(v);
            }
        }

    }
    printf("  No Solution Possible\n");
}
string s;
bool read_input() {

    string  ch;
    cin >> s; if (s == "END")return false;
    cout << s << endl;

    cin >> r0 >> c0 >>ch>>r2>>c2;//mxr=max(r0,r)

    dir = dir_id(ch[]);
    r1 = r0 + dr[dir];
    c1 = c0 + dc[dir];
    memset(has_edge, , sizeof(has_edge));
    //node u1 (r0, c0, dir);
    //u1 = walk(u1, dir);
    //r1 = u1.r, c1 = u1.c, dir = u1.dir;
    int c, r;
    while (cin >> r) {
        if (r == )break;
        cin >> c;
        char ss[];
        for (;;) {
            scanf("%s", ss);
            if (ss[] == '*')break;
            for (int i = ; i < strlen(ss); i++)
                has_edge[r][c][dir_id(ss[])][turn_id(ss[i])]=;
        }
    }
    return true;
}
int main(){
    while (read_input()) {

        solve();
    }

    system("pause");
    return ;
}