每天一道算法題(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位的循環也可以達到同樣的結果。