程序设计思维与实践 Week10 实验

A 签到题

1.题目大意

东东有一个字符串X，该串包含偶数个字符，一半是 S 字符，一半是 T 字符
东东可以对该字符串执行 1010000 次操作：如果存在 ST 是该串的子串，则删除掉最左边的 ST。
即 TSTTSS⇒TTSS、SSSTTT⇒SSTT⇒ST⇒空

输入：
(2 ≦ |X| ≦ 200,000)

输出：
输出最终串的长度

样例：

TSTTSS

4

2. 思路历程

• 由于只需求最终段的长度，而无需求最终段的具体字符，因此每次删除掉最左边的 ST 可以转变为每次删掉最先成对的 ST，这样用栈求解就很方便了。

3. 具体实现

• 遍历字符串，对每个字符的入栈条件进行判断：若入栈后与栈顶元素构成 ST 对，则不入栈且弹出栈顶元素；若不构成 ST 对，则入栈，即

1. 入栈条件：栈为空 或 栈顶元素和当前字符都为S 或 栈顶元素为 T
2. 弹栈条件：栈顶元素为 S 且当前元素为 T

4. 代码

#include <iostream>
#include <algorithm>
#include <stack>
#include <string.h>
using namespace std;

string s;
stack<char> stk;

int main()
{
    cin >> s;
    long len = s.size();
    for (int i = 0; i < len; i++)
    {
        if (stk.empty() || (stk.top() == 'S' && s[i] == 'S') || stk.top() == 'T')
            stk.push(s[i]);
        
        if (stk.top() == 'S' && s[i] == 'T')
            stk.pop();
    }
    cout << stk.size();
    
    return 0;
}

B 东东转魔方

1.题目大意

东东有一个二阶魔方，即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。你可以展开表面以获得平面图如下所示。

+ - + - + - + - + - + - +
| q | r | a | b | u | v |
+ - + - + - + - + - + - +
| s | t | c | d | w | x |
+ - + - + - + - + - + - +
        | e | f |
        + - + - +
        | g | h |
        + - + - +
        | i | j |
        + - + - +
        | k | l |
        + - + - +
        | m | n |
        + - + - +
        | o | p |
        + - + - +

输出：
对于每个测试用例，魔方如果可以至多 “只转一步” 恢复，输出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

2. 思路历程

• 刚开始题目的输入一堆坐标看懵了，意会了好久才发现24个数就是按照示意图a~x的顺序读入的，六个面一面4个数按照顶前下后左右的面顺序读入。
• 只能转一次还原二阶魔方，因此操作只有6个，可以分成3类：（面向魔方的前面）

1. 分成左右部分，向前或者向后转
   1）保持不变的面：左面和右面
   2）旋转的面展开如下：

+ - + - +
| a | b |
+ -top- +
| c | d |
+ - + - +
| e | f |
+ -frt- +
| g | h |
+ - + - +
| i | j |
+ -dwn- +
| k | l |
+ - + - +
| m | n |
+ -bck- +
| o | p |
+ - + - +

2. 分成前后部分，向上或者向下转
   1）保持不变的面：前面和后面
   2）旋转的面展开如下：

+ - + - + - + - + - + - + - + - +
| q | r | a | b | u | v | l | k |
+ -lft- + -top- + -rgt- + -dwn- +
| s | t | c | d | w | x | j | i |
+ - + - + - + - + - + - + - + - +

3. 分成上下部分，向左或者向右转
   1）保持不变的面：上面和下面
   2）旋转的面展开如下：

+ - + - + - + - + - + - + - + - +
| r | t | a | b | w | u | p | o |
+ -lft- + -frt- + -rgt- + -bck- +
| q | s | c | d | x | v | n | m |
+ - + - + - + - + - + - + - + - +

• 对于每个类型，考虑两个相反的旋转方向即可，由于操作数和旋转方式都比较少，可以采用枚举的方法。

3. 具体实现

• 创建数组a存储魔方每一格的数据，a[i][j]表示第i个面第j个数的颜色。
• 先对魔方的类型进行初判，如果a[1][1] != a[1][2]则有必要进行前后旋转，若a[1][1] != a[1][3]则有必要进行左右旋转，若a[2][1] != a[2][3]则有必要进行上下旋转，剩下的考虑不旋转。
• 每种类型考虑相反两方向旋转，直接考虑每格与斜对角格是否同颜色即可。

4. 代码

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

int n;
int a[7][5];

bool noRotate()
{
    for (int i = 1; i <= 6; i++)
    {
        if(a[i][1] != a[i][2] || a[i][2] != a[i][3] || a[i][3] != a[i][4])
            return false;
    }
    return true;
}

bool rotate()
{
    // 分成左右部分
    if (a[1][1] != a[1][2])
    {
        if((a[5][1] == a[5][2] && a[5][2] == a[5][3] && a[5][3] == a[5][4]) && (a[6][1] == a[6][2] && a[6][2] == a[6][3] && a[6][3] == a[6][4]) && (a[1][2] == a[1][4] && a[2][2] == a[2][4] && a[3][2] == a[3][4] && a[4][2] == a[4][4]) && (a[1][1] == a[1][3] && a[2][1] == a[2][3] && a[3][1] == a[3][3] && a[4][1] == a[4][3]))
        {
            if (a[1][1] == a[2][2] && a[2][1] == a[3][2] && a[3][1] == a[4][2] && a[4][1] == a[1][2])
                return true;
            if (a[2][1] == a[1][2] && a[3][1] == a[2][2] && a[4][1] == a[3][2] && a[1][1] == a[4][2])
                return true;
        }
        return false;
    }
    
    // 分成前后部分
    if (a[1][1] != a[1][3])
    {
        if ((a[2][1] == a[2][2] && a[2][2] == a[2][3] && a[2][3] == a[2][4]) && (a[4][1] == a[4][2] && a[4][2] == a[4][3] && a[4][3] == a[4][4]) && (a[1][1] == a[1][2] && a[3][1] == a[3][2] && a[5][1] == a[5][2] && a[6][1] == a[6][2]) && (a[1][3] == a[1][4] && a[3][3] == a[3][4] && a[5][3] == a[5][4] && a[6][3] == a[6][4]))
        {
            if (a[5][3] == a[1][1] && a[1][3] == a[6][1] && a[6][3] == a[3][4] && a[3][2] == a[5][1]) // 第三面折上去四个面顺序不同
                return true;
            if (a[1][1] == a[6][3] && a[6][1] == a[3][2] && a[3][4] == a[5][3] && a[5][1] == a[1][3])
                return true;
        }
        return false;
    }
    
    // 分成上下部分
    if (a[2][1] != a[2][3])
    {
        if ((a[1][1] == a[1][2] && a[1][2] == a[1][3] && a[1][3] == a[1][4]) && (a[3][1] == a[3][2] && a[3][2] == a[3][3] && a[3][3] == a[3][4]) && (a[2][1] == a[2][2] && a[4][1] == a[4][2] && a[5][1] == a[5][3] && a[6][1] == a[6][3]) && (a[2][3] == a[2][4] && a[4][3] == a[4][4] && a[5][2] == a[5][4] && a[6][2] == a[6][4]))
        {
            if (a[2][1] == a[5][1] && a[5][2] == a[4][2] && a[4][4] == a[6][4] && a[6][3] == a[2][3])
                return true;
            if (a[2][1] == a[6][4] && a[5][2] == a[2][3] && a[4][4] == a[5][1] && a[6][3] == a[4][2])
                return true;
        }
        return false;
    }
    
    return noRotate();
}

int main()
{
    cin >> n;
    while (n--)
    {
        for (int i = 1; i <= 6; i++)
            for (int j = 1; j <= 4; j++)
                cin >> a[i][j];
        
        if (rotate()) cout << "YES" << endl;
        else cout << "NO" << endl;
         
    }
    return 0;
}