【紫书】【重要】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 = 10+5;

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[] = { -1,0,1,0 };
const int dc[] = { 0,1,0,-1 };
//NESW
int r1, c1,r0,c0,r2,c2,dir,mxr,mxc;

struct node {
    int r, c, dir;
    node(int r = 0, int c = 0, int dir = 0) :r(r), c(c), dir(dir) {}
};
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);
}
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>=1&&r<=9&&c>=1&&c<=9);
}
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) cout << ' ';
        printf(" (%d,%d)", nodes[i].r, nodes[i].c);
        if (++cnt % 10 == 0) cout << endl;
    }
    if (nodes.size() % 10 != 0)cout << endl;
}
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()) {
        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&&inside(v.    r,v.c)) {
                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");
}
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[0]);
    r1 = r0 + dr[dir];
    c1 = c0 + dc[dir];
    memset(has_edge, 0, 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 == 0)break;
        cin >> c;
        char ss[10];
        for (;;) {
            scanf("%s", ss);
            if (ss[0] == '*')break;
            for (int i = 1; i < strlen(ss); i++)
                has_edge[r][c][dir_id(ss[0])][turn_id(ss[i])]=1;
        }
    }
    return true;
}
int main(){
    while (read_input()) {
        
        solve();
    }
    
    system("pause");
    return 0;
}

 

转载于:https://www.cnblogs.com/SuuT/p/8820716.html