宇航员 POJ 1835

题目 

链接 宇航员

问题描述： 
　　宇航员在太空中迷失了方向，在他的起始位置现在建立一个虚拟xyz坐标系，称为绝对坐标系，宇航员正面的方向为x轴正方向，头顶方向为z轴正方向，则宇航员的初始状态如下图所示：

现对六个方向分别标号，x，y，z正方向分别为0，1，2，负方向分别为3，4，5；称它们为绝对方向。宇航员在宇宙中只沿着与绝对坐标系xyz轴平行的方向行走，但是他不知道自己当前绝对坐标和自己面向的绝对方向。 

任务描述： 
　　请根据宇航员对自己在相对方向上移动的描述确定宇航员最终的绝对坐标和面向的绝对方向。对在相对方向上移动的描述及意义如下： 
forward x 　向前走x米。 
back x　先转向后，再走x米。 
left x 先转向左，再走x米。 
right x 先转向右，再走x米。 
up x 先面向上，再走x米。 
down x 先面向下，再走x米。 
其中向上和向下如下图所示： 

Input

第一行一个正整数m，表示测试数据的组数。每组测试数据第一行是一个正整数n(1<=n<=10000)表示宇航员行走的次数，下面n行每行输入一次相对行走，格式如上所述，其中( 1 <= x <= 10000 为正整数)。

Output

对于每组输入数据输出一行，x y z p, 中间用空格隔开，x y z是宇航员的位置的绝对坐标，p是宇航员面向的绝对方向编号（0<=p <=5）。

Sample Input

1
6
left 10
right 11
up 12
down 13
forward 14
back 15

Sample Output

23 -10 12 3

思路

1. 模拟。建立描述宇航员状态的变量，模拟每次操作，看最后宇航员的状态。 看了大神们的题解，我这种方法有点烦

细节

1. 向上和向下转。最开始没理解透题意。
2. 每次循环要清空对象。。。。

代码

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <string>
#include <cctype>

using namespace std;

class rover{
private:
	enum  dir{
		PXD = 0,
		PYD = 1,
		PZD = 2,
		NXD = 3,
		NYD = 4,
		NZD = 5
	};
	struct spos{
		dir fDir, tDir;
		long long x,y,z;
	};

	spos sp;
public:
	rover(int x = 0, int y = 0, int z = 0, int fd = 0, int td = 2) {sp.x = x; sp.y = y; sp.z = z; sp.fDir = (dir)fd; sp.tDir = (dir)td; }
	void resetRover(int x = 0, int y = 0, int z = 0, int fd = 0, int td = 2) {sp.x = x; sp.y = y; sp.z = z; sp.fDir = (dir)fd; sp.tDir = (dir)td; }
	void turn_forward(int d);
	void turn_back(int d);
	void turn_left(int d);
	void turn_right(int d);
	void turn_up(int d);
	void turn_down(int d);
	void turn(string str, int d);
	void turn(char * str, int d);
	void dispPos(void);
	void dirReverse(dir & dr);
};

int main()
{
//#define LOCL

#ifdef LOCL
	freopen("data.in", "r", stdin);
//	freopen("data.out", "w+", stdout);
#endif // LOCL

    int m,n;
	int d;
//	string ds;
	char ds[100];
	rover astr;

    cin >> m;
    while (m--) {
		cin >> n;
		astr.resetRover();
		while (n--) {

//			ds.clear();
//			cin >> ds;
//			cin >> d;
			//n ~ 10000 cin 会超时。。。
			scanf("%s %d", ds, &d);
			astr.turn(ds, d);
		}
		astr.dispPos();
    }

    return 0;
}

void rover::dirReverse(dir & dr) {
	switch(dr) {
		case PXD:
			dr = NXD;
			break;
		case NXD:
			dr = PXD;
			break;
		case PYD:
			dr = NYD;
			break;
		case NYD:
			dr = PYD;
			break;
		case PZD:
			dr = NZD;
			break;
		case NZD:
			dr = PZD;
			break;

		default:
			break;

	}
}

//void rover::turn(string str, int d) {
//	transform(str.begin(), str.end(), str.begin(), ::tolower);
	if (str == "left") turn_left(d);
	else if (str == "right") turn_right(d);
	else if (str == "up") turn_up(d);
	else if (str == "down") turn_down(d);
	else if (str == "forward") turn_forward(d);
	else if (str == "back")   turn_back(d);
	cout << "command: " << str << " " << d << endl;
//	if (str[0] == 'l') turn_left(d);
//	else if (str[0] == 'r') turn_right(d);
//	else if (str[0] == 'u') turn_up(d);
//	else if (str[0] == 'd') turn_down(d);
//	else if (str[0] == 'f') turn_forward(d);
//	else if (str[0] == 'b')   turn_back(d);
	else cout << "command erro: " << str << endl;
//}

void rover::turn(char * str, int d) {
	if (str[0] == 'l') turn_left(d);
	else if (str[0] == 'r') turn_right(d);
	else if (str[0] == 'u') turn_up(d);
	else if (str[0] == 'd') turn_down(d);
	else if (str[0] == 'f') turn_forward(d);
	else if (str[0] == 'b')   turn_back(d);
}
void rover::turn_forward(int d) {
	switch (sp.fDir) {
		case PXD:
			sp.x += d;
			break;
		case NXD:
			sp.x -= d;
			break;
		case PYD:
			sp.y += d;
			break;
		case NYD:
			sp.y -= d;
			break;
		case PZD:
			sp.z += d;
			break;
		case NZD:
			sp.z -= d;
			break;
		default:
			break;
	}
}

void rover::turn_back(int d) {
//	sp.fDir = (dir)(((int)sp.fDir+3) % 6);
//	sp.fDir = (dir)((int)sp.fDir % 6);
	dirReverse(sp.fDir);
	turn_forward(d);
}

void rover::turn_down(int d) {
	swap(sp.fDir, sp.tDir);
	dirReverse(sp.fDir);
	turn_forward(d);
}

void rover::turn_up(int d) {
	swap(sp.fDir, sp.tDir);
	dirReverse(sp.tDir);

	turn_forward(d);
}

void rover::turn_left(int d) {
	switch (sp.tDir) {
		case PXD:
			switch (sp.fDir) {
				case PZD:
					sp.fDir = PYD;
					break;
				case PYD:
					sp.fDir = NZD;
					break;
				case NZD:
					sp.fDir = NYD;
					break;
				case NYD:
					sp.fDir = PZD;
					break;
				default:
					break;
			}
			break;
		case NXD:
			switch (sp.fDir) {
				case PZD:
					sp.fDir = NYD;
					break;
				case NYD:
					sp.fDir = NZD;
					break;
				case NZD:
					sp.fDir = PYD;
					break;
				case PYD:
					sp.fDir = PZD;
					break;
				default:
					break;
			}
			break;
		case PYD:
			switch (sp.fDir) {
				case PZD:
					sp.fDir = NXD;
					break;
				case NXD:
					sp.fDir = NZD;
					break;
				case NZD:
					sp.fDir = PXD;
					break;
				case PXD:
					sp.fDir = PZD;
					break;
				default:
					break;
			}
			break;
		case NYD:
			switch (sp.fDir) {
				case PZD:
					sp.fDir = PXD;
					break;
				case PXD:
					sp.fDir = NZD;
					break;
				case NZD:
					sp.fDir = NXD;
					break;
				case NXD:
					sp.fDir = PZD;
					break;
				default:
					break;
			}
			break;
		case PZD:
			switch (sp.fDir) {
				case PYD:
					sp.fDir = PXD;
					break;
				case PXD:
					sp.fDir = NYD;
					break;
				case NYD:
					sp.fDir = NXD;
					break;
				case NXD:
					sp.fDir = PYD;
					break;
				default:
					break;
			}
			break;
		case NZD:
			switch (sp.fDir) {
				case PXD:
					sp.fDir = PYD;
					break;
				case PYD:
					sp.fDir = NXD;
					break;
				case NXD:
					sp.fDir = NYD;
					break;
				case NYD:
					sp.fDir = PXD;
					break;
				default:
					break;
			}
			break;
		default:
			break;
	}

	turn_forward(d);
}

void rover::turn_right(int d) {
	dirReverse(sp.fDir);
	turn_left(d);
}

void rover::dispPos() {
	int x_disp = sp.x, y_disp = sp.y, z_disp = sp.z;
	cout << x_disp << " "   << y_disp << " " << z_disp
		 << " " << sp.fDir
		 << endl;
//		 << " tpos:" << sp.tDir <<endl;
}