UVA816 Abbott‘s Revenge

紫书标准版本实现：https://blog.csdn.net/qq_15096707/article/details/43938325 ，这个链接的博主代码很标准。

这道题很容易PE，标准的BFS题目，但是这道题处理起来并不容易。

#include<iostream>
#include<algorithm>
#include<queue>
#include<cmath>
#include<math.h>
#include<string>
#include<string.h>
#include<map>
#include<set>
#include<stack>
#include <sstream>
//#include <Eigen/Dense>
//#include <Eigen/Geometry>
//using namespace Eigen;

using namespace std;



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 };

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)//返回turn之后的dir
{
	int dir = u.dir;
	if (turn == 1) //NESW不同方位右转等价于逆时针旋转dir
		dir = (dir + 3) % 4;
	if (turn == 2) //NESW不同方位左转等价于顺时针旋转dir
		dir = (dir + 1) % 4;
	return Node(u.r + dr[dir], u.c + dc[dir], dir);
}
const int maxn = 20;
Node p[maxn][maxn][4];
int has_edge[maxn][maxn][4][3], vis[maxn][maxn][4];
int r0, c0, r1, c1, r2, c2, dir;
string maze_name;

void print_ans(Node u)
{
	vector<Node> nodes;
	Node temp(r1, c1, dir);
	while (true) 
	{
		nodes.push_back(u);
		if (temp.r == u.r && temp.c == u.c && temp.dir == u.dir)
			break;
		u = p[u.r][u.c][u.dir];
	}
	nodes.push_back(Node(r0, c0, dir));//加上r0,c0
	cout << maze_name << endl;
	//打印解，每行10个
	int cnt = 0;
	for (int i = nodes.size() - 1; i >= 0; i--) 
	{
		if (cnt % 10 == 0) 
			cout << " ";
		cout << " (" << nodes[i].r << "," << nodes[i].c << ")";
		if (++cnt % 10 == 0) 
			cout << endl;
	}
	if (nodes.size() % 10 != 0) cout << endl;
}
//题设限制，最多9行9列
int inside(Node v)
{
	if (v.r > 9 || v.c > 9 || v.r < 1 || v.c < 1)
		return 0;
	return 1;
}

void solve()
{
	queue<Node> q;
	memset(vis, 0, sizeof(vis));
	Node u(r1, c1, 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 = 0; i < 3; i++)
		{
			Node v = walk(u, i);//v为u点turn之后的坐标和方向
			//vis[v.r][v.c][v.dir]表示同点同方向走过的路不会重复走
			if (has_edge[u.r][u.c][u.dir][i] && !vis[v.r][v.c][v.dir] && inside(v))
			{

				vis[v.r][v.c][v.dir] = 1;
				p[v.r][v.c][v.dir] = u;
				q.push(v);
			}
		}
	}
	cout << maze_name << endl;
	cout << "  No Solution Possible" << endl;
}
int main()
{
	while (cin >> maze_name)
	{
		if (maze_name == "END")
			break;
		char dir0;
		cin >> r0 >> c0 >> dir0 >> r2 >> c2;
		dir = dir_id(dir0);
		r1 = r0 + dr[dir];//第1步移动后的行
		c1 = c0 + dc[dir];//第1步移动后的列
		int pr, pc, pdir, pturn;
		memset(has_edge, 0, sizeof(has_edge));
		while (cin >> pr)
		{
			if (pr == 0)
				break;
			cin >> pc;
			string temp;
			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表示，从pdir方向进入(pr,pc)，可以pturn走
					has_edge[pr][pc][pdir][pturn] = 1;
				}
			}
		}
		solve();
	}
}

//lrj
#include<iostream>
#include<vector>
#include<algorithm>
#include<string.h>
#include<string>
#include<queue>
using namespace std;

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 };


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);
}
const int maxn = 20;
Node p[maxn][maxn][4];
int has_edge[maxn][maxn][4][3], d[maxn][maxn][4];
int r0, c0, r1, c1, r2, c2, dir;
string maze_name;

void print_ans(Node u)
{
	vector<Node> nodes;
	while (true) {
		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));
	cout << maze_name << endl;
	//打印解，每行10个
	int cnt = 0;
	for (int i = nodes.size() - 1; i >= 0; i--) {
		if (cnt % 10 == 0) cout << " ";
		cout << " (" << nodes[i].r << "," << nodes[i].c << ")";
		if (++cnt % 10 == 0) cout << endl;
	}
	if (nodes.size() % 10 != 0) cout << endl;
}
int inside(Node v)
{
	if (v.r > 9 || v.c > 9 || v.r < 1 || v.c < 1)
		return 0;
	return 1;
}
void solve()
{
	queue<Node> q;
	memset(d, -1, sizeof(d));
	Node u(r1, c1, dir);
	d[r1][c1][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))
			{
			
				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;
}
int main()
{
	while (cin >> maze_name)
	{
		if (maze_name == "END")
			break;
		char dir0;
		cin >> r0 >> c0 >> dir0 >> r2 >> c2;
		dir = dir_id(dir0);
		r1 = r0 + dr[dir];
		c1 = c0 + dc[dir];
		int pr, pc, pdir, pturn;
		memset(has_edge, 0, sizeof(has_edge));
		while (cin >> pr)
		{
			if (pr == 0)
				break;
			cin >> pc;
			string temp;
			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;
				}
			}
		}
		solve();	
	}
}