每天一道算法题(33)——阿里巴巴之魔方翻转

题目：

    阿里巴巴2015秋招机试题目：

一个三阶魔方由六个面组成，颜色分别是白色（W）、对面为黄色（Y）、红色（R）、对面为橙色（O）、绿色（G）、对面为蓝色（B）。如果手持魔方，白色向上，红色朝向自己，则绿色在左手侧。

请写一个程序，对一个处于还原状态（各面各块同色）的魔方，进行操作，打印操作后的魔方状态。操作指令为单个操作指令组成的字符串。单个操作指令包括：
1）U：白色面顺时针旋转90度
2）D：黄色面顺时针旋转90度
3）F：红色面顺时针旋转90度
4）B：橙色面顺时针旋转90度
5）L：绿色面顺时针旋转90度
6）R：蓝色面顺时针旋转90度
其中顺时针旋转定义为将该面朝向自己时的顺时针方向。
按WYROGB的顺序输出经过操作后6个面的状态。每个面首先输出中心块颜色，然后从此面面向自己时的左下角块开始，顺时针顺出每块的颜色。输出一面后换行。
请设计一个数据结构表示魔方，并基于该数据结构完成功能。
请用C/C++，Java或Python语言实现。请注意尽量以可成功编译或可直接运行为标准来编写代码。
 
示例：
输入：
LR
输出：
WOOOWRRRW
YRRRYOOOY
RWWWRYYYR
OYYYOWWWO
GGGGGGGGG

BBBBBBBBB

代码：

       定义面的类。涉及输出函数，面与面之间上下左右4个方向、3个方向块的两两对应交换或者逆转交换函数exchange。

class face{// each face
public:
int color[3][3];
face(){
		for(int i=0;i<3;i++)
			for(int j=0;j<3;j++)
			   color[i][j]=-1;
}
face(const face& f){
		for(int i=0;i<3;i++)
		for(int j=0;j<3;j++)
			color[i][j]=f.color[i][j];
}
void inni(int c){
	for(int i=0;i<3;i++)
		for(int j=0;j<3;j++)
			   color[i][j]=c;
  }
void exChange(const face& f,char source,char dest,bool flag=false);
void selfChange();
void trans(int i);
void print();
};
void face::print(){//print one face; 
	trans(color[1][1]);
	trans(color[2][0]);trans(color[1][0]);trans(color[0][0]);
	trans(color[0][1]);trans(color[0][2]);trans(color[1][2]);
	trans(color[2][2]);trans(color[2][1]);
	cout<<endl;
}
void face::trans(int i){
		switch(i){
		case 0:
			cout<<'W';break;
		case 1:
			cout<<'Y';break;		
		case 2:
			cout<<'R';break;		
		case 3:
			cout<<'O';break;		
		case 4:
			cout<<'G';break;
		case 5:
			cout<<'B';break;
	}
}
void face::exChange(const face& f,char source,char dest,bool flag){//the 'source' color of  f to dest color of current face, u-d-l-r means direction, 
	int data[3];
	switch(source){
			case 'U'://操作
			{
				data[0]=f.color[0][0];
				data[1]=f.color[0][1];
				data[2]=f.color[0][2];
				break;
			}
		  case 'D':
			{
				data[0]=f.color[2][0];
				data[1]=f.color[2][1];
				data[2]=f.color[2][2];
				break;
			}	
		case 'L':
			{
				data[0]=f.color[0][0];
				data[1]=f.color[1][0];
				data[2]=f.color[2][0];
				break;
			}		
		case 'R':
			{
				data[0]=f.color[0][2];
				data[1]=f.color[1][2];
				data[2]=f.color[2][2];
				break;
			}
	}
	if(flag){
		int temp=data[0];
		data[0]=data[2];
		data[2]=temp;
	}
	switch(dest){
		case 'U'://操作
			{
				color[0][0]=data[0];
				color[0][1]=data[1];
				color[0][2]=data[2];
				break;
			}
		  case 'D':
			{
				color[2][0]=data[0];
				color[2][1]=data[1];
				color[2][2]=data[2];
				break;
			}	
		case 'L':
			{
				color[0][0]=data[0];
				color[1][0]=data[1];
				color[2][0]=data[2];
				break;
			}		
		case 'R':
			{
				color[0][2]=data[0];
				color[1][2]=data[1];
				color[2][2]=data[2];
				break;
			}
	}
}//the color 
void face::selfChange(){// the change of current face
	int temp;
	temp=color[0][0];
	color[0][0]=color[2][0];
	color[2][0]=color[2][2];
	color[2][2]=color[0][2];
	color[0][2]=temp;

	temp=color[0][1];
	color[0][1]=color[1][0];
	color[1][0]=color[2][1];
	color[2][1]=color[1][2];
	color[1][2]=temp;
}//

         定义魔方类。定义某一种旋转时,颜色变动函数change。此时，面朝自己的魔方会变化selfchange()，且该面接壤的四个面的上下左右的四个方向之一，组成链式4次变动。

class cube{
	face mian[6];
public :
	cube(){
		for(int i=0;i<6;i++)
			mian[i].inni(i);
	}
	void print(){
		for(int i=0;i<6;i++)
			mian[i].print();
	}
	void change(char o);
};


void cube::change(char op){
	face* f=NULL;
	switch(op){
		case 'U':
			{
				mian[0].selfChange();
				f=new face(mian[2]);
				mian[2].exChange(mian[5],'U','U');
				mian[5].exChange(mian[3],'U','U');
				mian[3].exChange(mian[4],'U','U');
				mian[4].exChange(*f,'U','U');
				break;
			}
		case 'D':
			{
				mian[1].selfChange();
				f=new face(mian[2]);
				mian[2].exChange(mian[4],'D','D');
				mian[4].exChange(mian[3],'D','D');
				mian[3].exChange(mian[5],'D','D');
				mian[2].exChange(*f,'D','D');			
				break;
			}	
		case 'F':
			{
				mian[2].selfChange();
				f=new face(mian[4]);
				mian[4].exChange(mian[1],'U','R');
				mian[1].exChange(mian[5],'L','U',true);
				mian[5].exChange(mian[0],'D','L');
				mian[0].exChange(*f,'R','D',true);
				break;
			}		
		case 'B':
			{
				mian[3].selfChange();
				f=new face(mian[0]);
				mian[0].exChange(mian[5],'R','U');
				mian[5].exChange(mian[1],'D','R',true);
				mian[1].exChange(mian[4],'L','D');
				mian[4].exChange(*f,'U','L',true);
				break;
			}
		case 'L':
			{
				mian[4].selfChange();
				f=new face(mian[0]);
				mian[0].exChange(mian[3],'R','L',true);
				mian[3].exChange(mian[1],'L','R',true);
				mian[1].exChange(mian[2],'L','L');
				mian[2].exChange(*f,'L','L');
				break;
			}
		case 'R':
			{
				mian[5].selfChange();
				f=new face(mian[0]);
				mian[0].exChange(mian[2],'R','R');
				mian[2].exChange(mian[1],'R','R');
				mian[1].exChange(mian[3],'L','R',true);
				mian[3].exChange(*f,'R','L',true);
				break;
			}
	}
	if(f)
	     delete f;
	return ;
}

       主函数

int main()
{
	string s;
	getline(cin,s);
	cube c;
	if(!s.empty())
	   for(int i=0;i<s.size();i++)
		   c.change(s[i]);
	c.print();
	return 0;
}

        注意，由于定义的魔方的上下左右方向不一致，可能发生输出不一定相同，但是除去第一个中心元素外，其它元素组成的链经过若干次移位2位的循环也可以达到同样的结果。