week10实验面向T3训练

A - 签到题

题目

东东有一个字符串X，该串包含偶数个字符，一半是 S 字符，一半是 T 字符
东东可以对该字符串执行 1010000 次操作：如果存在 ST 是该串的子串，则删除掉最左边的 ST。
即 TSTTSS⇒TTSS、SSSTTT⇒SSTT⇒ST⇒空
input(2 ≦ |X| ≦ 200,000)
output输出最终串的长度
sample

TSTTSS

4

解题思路

使用栈会非常方便，每当输入一个char，如果栈中为空，则直接push，若栈中不为空，判断栈顶和输入字符是否是"ST"，是则pop。

代码

#include<iostream>
#include<stdio.h>
#include<stack>
using namespace std;
int main()
{
	stack<char> S;
	char c;
	while(scanf("%c",&c)!=EOF&&c!='\n')
	{
		if(S.empty())
		{
			S.push(c);
			continue;
		}
		char cc=S.top();
		S.push(c);
		
		if(c=='T'&&cc=='S')
		{
			S.pop();S.pop();
		}
	}
	cout<<S.size();
	
	return 0;
 } 

B - 东东转魔方

题目

东东有一个二阶魔方，即2×2×2的一个立方体组。立方体由八个角组成。

魔方的每一块都用三维坐标(h, k, l)标记，其中h, k, l∈{0,1}。六个面的每一个都有四个小面，每个小面都有一个正整数。

对于每一步，东东可以选择一个特定的面，并把此面顺时针或逆时针转90度。

请你判断，是否东东可以在一个步骤还原这个魔方（每个面没有异色）。

input
输入的第一行包含一个整数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。你可以展开表面以获得平面图

如下所示。

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

友情提示：如果能思考一下解题框架的设计是最好的，一上来就莽很痛苦
友情提示：如果能思考一下解题框架的设计是最好的，一上来就莽很痛苦
友情提示：如果能思考一下解题框架的设计是最好的，一上来就莽很痛苦

sample

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

解题思路

将魔方的每一个小面按照输入顺序编上编号1~24形成数组e。

每当输入一个魔方的各小面数字后，若要判断它是否可以在一个步骤内还原魔方，那么有12种方法，分别为，顶面、底面、前面、背面、左面、后面各顺时针、逆时针转动。当按照其中的一种方法转动时，小面对应的数字会变化，即e数组中数字变化，具体在代码中有体现。若在变换中六面数字同色，那么就可以输出yes，否则输出no。

代码

#include<iostream>
using namespace std;

int e[30]={0};

bool judge(int *ee)
{
	for(int i=1;i<=21;)//注意此时无需i++
	{
		
		if(ee[i]!=ee[i+1]||ee[i]!=ee[i+2]||ee[i]!=ee[i+3])
			return false;
		i+=4;
	}
	return true;
}
void init(int *eet)
{
	for(int i=1;i<=24;i++)
		eet[i]=e[i];
}
bool solve()
{
	int et[25];
	init(et);
	if(judge(et)==true)return true;//初始状态就是YES
	//12种选择
	
	//顶面
	//顺时针
	init(et);
	et[5]=e[23],et[6]=e[21],et[15]=e[20],et[16]=e[18];
	et[18]=e[5],et[20]=e[6],et[21]=e[15],et[23]=e[16];
	bool v=judge(et);
	if(v==true)return true;
	//逆时针 
	init(et);
	et[5]=e[18],et[6]=e[20],et[15]=e[21],et[16]=e[23];
	et[18]=e[16],et[20]=e[15],et[21]=e[6],et[23]=e[5];
	v=judge(et);
	if(v==true)return true;


	//前面顺、逆
	init(et);
	et[3]=e[19],et[4]=e[20],et[9]=e[24],et[10]=e[23];
	et[19]=e[10],et[20]=e[9],et[23]=e[3],et[24]=e[4];
	v=judge(et);
	if(v==true)return true;
	init(et);
	et[3]=e[23],et[4]=e[24],et[9]=e[20],et[10]=e[19];
	et[19]=e[3],et[20]=e[4],et[23]=e[10],et[24]=e[92];
	v=judge(et);
	if(v==true)return true;
	
	
	//底面
	init(et);
	et[7]=e[17],et[8]=e[19],et[13]=e[22],et[14]=e[24];
	et[17]=e[14],et[19]=e[13],et[22]=e[8],et[24]=e[7];
	v=judge(et);
	if(v==true)return true;
	init(et);
	et[7]=e[19],et[8]=e[17],et[13]=e[19],et[14]=e[17];
	et[17]=e[7],et[19]=e[8],et[22]=e[13],et[24]=e[14];
	v=judge(et);
	if(v==true)return true;


	//背面
	init(et);
	et[1]=e[17],et[2]=e[18],et[11]=e[22],et[12]=e[21];
	et[17]=e[12],et[18]=e[11],et[21]=e[1],et[22]=e[2];
	v=judge(et);
	if(v==true)return true;
	init(et);
	et[1]=e[21],et[2]=e[22],et[11]=e[18],et[12]=e[17];
	et[17]=e[1],et[18]=e[2],et[21]=e[12],et[22]=e[11];
	v=judge(et);
	if(v==true)return true;
	
	
	//左面
	init(et);
	et[1]=e[13],et[3]=e[15],et[5]=e[1],et[7]=e[3];
	et[9]=e[5],et[11]=e[7],et[13]=e[9],et[15]=e[11];
	v=judge(et);
	if(v==true)return true;
	init(et);
	et[1]=e[5],et[3]=e[7],et[5]=e[3],et[7]=e[10];
	et[9]=e[7],et[11]=e[5],et[13]=e[10],et[15]=e[3];
	v=judge(et);
	if(v==true)return true;
	
	
	//右面
	init(et);
	et[2]=e[6],et[4]=e[8],et[6]=e[10],et[8]=e[12];
	et[10]=e[14],et[12]=e[16],et[14]=e[2],et[16]=e[4];
	v=judge(et);
	if(v==true)return true;
	init(et);
	et[2]=e[14],et[4]=e[16],et[6]=e[2],et[8]=e[4];
	et[10]=e[6],et[12]=e[8],et[14]=e[10],et[16]=e[12];
	v=judge(et);
	if(v==true)return true;
	 
	return false;
}

int main()
{
	int n;
	cin>>n;
	while(n--)
	{
		for(int i=1;i<=24;i++)
			cin>>e[i];
		//判断是否可以还原 
		if(solve()==true)cout<<"YES"<<endl;
		else cout<<"NO"<<endl;
	}
	return 0;
}