week10-魔方

题目：

东东有一个二阶魔方，即2×2×2的一个立方体组。立方体由八个角组成。
魔方的每一块都用三维坐标(h, k, l)标记，其中h, k, l∈{0,1}。六个面的每一个都有四个小面，每个小面都有一个正整数。
对于每一步，东东可以选择一个特定的面，并把此面顺时针或逆时针转90度。
请你判断，是否东东可以在一个步骤还原这个魔方（每个面没有异色）。

输入：

输入的第一行包含一个整数N（N≤30），这是测试用例的数量。
对于每个测试用例， 第 1~4 个数描述魔方的顶面，这是常见的2×2面，由（0，0，1），（0，1，1），（1，0，1），（1，1，1）标记。四个整数对应于上述部分。
第 5~8 个数描述前面，即（1，0，1），（1，1，1），（1，0，0），（1，1，0）的公共面。四个整数 与上述各部分相对应。
第 9~12 个数描述底面，即（1，0，0），（1，1，0），（0，0，0），（0，1，0）的公共面。四个整数与上述各部分相对应。
第 13~16 个数描述背面，即（0，0，0），（0，1，0），（0，0，1），（0，1），（0，1，1）的公共面。四个整数与上述各部分相对应。
第 17~20 个数描述左面，即（0，0，0），（0，0，1），（1，0，0），（1，0，1）的公共面。给出四个整数与上述各部分相对应。
第 21~24 个数描述了右面，即（0，1，1），（0，1，0），（1，1，1），（1，1，0）的公共面。给出四个整数与上述各部分相对应。
换句话说，每个测试用例包含24个整数a、b、c到x。你可以展开表面以获得平面图

输出：

对于每个测试用例，魔方如果可以至多 “只转一步” 恢复，输出YES，则输出NO。

样例输入：

4
1 1 1 1 2 2 2 2 3 3 3 3 4 4 4 4 5 5 5 5 6 6 6 6
6 6 6 6 1 1 1 1 2 2 2 2 3 3 3 3 5 5 5 5 4 4 4 4
1 4 1 4 2 1 2 1 3 2 3 2 4 3 4 3 5 5 5 5 6 6 6 6
1 3 1 3 2 4 2 4 3 1 3 1 4 2 4 2 5 5 5 5 6 6 6 6

样例输出：

YES
YES
YES
NO

题解：

我们对于这个题，就按照他魔方的展开图对每一个位置进行标号。
我们二阶魔方之后6种转法，因此我们可以对每一种转法的每一个数的位置的变化进行操作。这样我们就能够模拟出我们魔方的操作。
判断是否能够还原，我们就把六种转动都试验一遍，看看其是否能够满足条件。这样我们就能够判断魔方转动是否能够满足条件。

完整代码：

#include <iostream>
#include <string>
#include <vector>
#include<algorithm>
using namespace std;


int N,a;
int g[100];
int h[100];
void copy(){
	for(int i=1;i<=24;i++) h[i]=g[i];
}
bool is(){
	int x=1,y;
	for(int i=1;i<=6;i++){
		y=x+2;
		for(x;x<=y;x++){
			if(h[x]!=h[x+1]) return false;
		}
		x++;
	}
	return true;
}
bool move1(){      
    copy();
    swap(h[2],h[6]);
    swap(h[4],h[8]);
    swap(h[6],h[10]);
    swap(h[8],h[12]);
    swap(h[10],h[14]);
    swap(h[12],h[16]);
    if(is()) return true;
    return false;
}
bool move2(){  
    copy();
    swap(h[14],h[10]);
    swap(h[16],h[12]);
    swap(h[10],h[6]);
    swap(h[12],h[8]);
    swap(h[6],h[2]);
    swap(h[8],h[4]);
	if(is()) return true;
    return false;
}
bool move3(){   
    copy();
	swap(h[18],h[5]);
    swap(h[20],h[6]);
    swap(h[5],h[23]);
    swap(h[6],h[21]);
    swap(h[21],h[15]);
    swap(h[23],h[16]);
    if(is()) return true;
    return false; 
}
bool move4(){   
    copy();
	swap(h[23],h[5]);
    swap(h[21],h[6]);
    swap(h[5],h[18]);
    swap(h[6],h[20]);
    swap(h[18],h[16]);
    swap(h[20],h[15]);
    if(is()) return true;
    return false; 
}
bool move5(){  
    copy();
	swap(h[20],h[9]);
    swap(h[19],h[10]);
    swap(h[9],h[24]);
    swap(h[10],h[23]);
    swap(h[23],h[3]);
    swap(h[24],h[4]);
    if(is()) return true;
    return false; 
}
bool move6(){
	copy();
	swap(h[23],h[10]);
    swap(h[24],h[9]);
    swap(h[9],h[20]);
    swap(h[10],h[19]);
    swap(h[20],h[4]);
    swap(h[19],h[3]);
    if(is()) return true;
    return false; 
}
bool zhuandong(int x){
	switch(x){
		case 1:
			if(move1()) return true;
			break;
		case 2:
			if(move2()) return true;
			break;
		case 3:
			if(move3()) return true;
			break;
		case 4:
			if(move4()) return true;
			break;
		case 5:
			if(move5()) return true;
			break;
		case 6:
			if(move6()) return true;
			break;
	}
	return false;
}

int main(){
    cin>>N;
    for(int i=1;i<=N;i++){
    	for(int l=1;l<=24;l++){
    			cin>>g[l];
		}
        copy();
		if(is()) cout<<"YES"<<endl;
		else{
			int o=1;
			for(int l=1;l<=6;l++){
			if(zhuandong(l)){
				cout<<"YES"<<endl;
				o=0;
				break;
			}	
		}
		if(o==1) cout<<"NO"<<endl;
		}
	}
    
	return 0;
} 

反思：

对于这种比较抽象但是具有实物模拟的题，我们要对于条件进行充分的判断和实现，将我们的思路寄托于实物模拟上。