PAT乙级1003

1003 我要经过！ (20分)

题目地址： https://pintia.cn/problem-sets/994805260223102976/problems/994805323154440192

“答案正确”是自动判题系统给出的最使人欢喜的回复。本题属于 PAT 的“答案正确”大派送 —— 只要读入的字符串知足下列条件，系统就输出“答案正确”，不然输出“答案错误”。

获得“答案正确”的条件是：

1. 字符串中必须仅有 P、 A、 T这三种字符，不能够包含其它字符；
2. 任意形如 xPATx 的字符串均可以得到“答案正确”，其中 x 或者是空字符串，或者是仅由字母 A 组成的字符串；
3. 若是 aPbTc 是正确的，那么 aPbATca 也是正确的，其中 a、 b、 c 均或者是空字符串，或者是仅由字母 A 组成的字符串。

如今就请你为 PAT 写一个自动裁判程序，断定哪些字符串是能够得到“答案正确”的。

输入格式：

每一个测试输入包含 1 个测试用例。第 1 行给出一个正整数 n (<10)，是须要检测的字符串个数。接下来每一个字符串占一行，字符串长度不超过 100，且不包含空格。

输出格式：

每一个字符串的检测结果占一行，若是该字符串能够得到“答案正确”，则输出 YES，不然输出 NO。

输入样例

8
PAT
PAAT
AAPATAA
AAPAATAAAA
xPATx
PT
Whatever
APAAATAA

输出样例

YES
YES
YES
YES
NO
NO
NO
NO

个人理解

这个符合条件的PAT字符串主要是有一个递归的嵌套，本身写两个看看就知道了。字符串必须所有由P、A、T组成。我分了三类。

1. I类。起始为P，中间任意数量的A，结束为T。PAT、PAAT、PAAAT、PA...AT。
2. II类。P和T之间只有一个A，两边有相同数量的A。APATA、AAPATAA、AAAPATAAA、A...APATA...A。
3. III类。P和T之间不止一个A，两边的A的数量也不相同，可是符合P左边A的数量 乘以 P和T之间A的数量 等于 P右边的数量也符合条件。

代码段

#include <iostream>
#include <string>
using namespace std;
int main() {
    int n = 0;
    cin >> n;
    string pats[n];
    for (int i = 0; i < n; i++) {
        cin >> pats[i];
    }
    for (int i = 0; i < n; i++) {
        string isRight = "NO";
        int pPosition = pats[i].find("PA");
        int tPosition = pats[i].find("AT");  // 实则为T位置前A的index
        // 若是PA 出如今AT以后，表示不符合规则
        if (pPosition >= tPosition) {
            cout << isRight << endl;
            continue;
        }
        // 判断P 和 T 之间是否所有为A
        bool isAllA = true;
        for (int j = pPosition + 1; j <= tPosition; j++) {
            if (pats[i][j] != 'A') {
                cout << isRight << endl;
                isAllA = false;
                break;
            }
        }
        if (!isAllA) {
            continue;
        }
        /*
        * I 类
        * 首先是PAT是符合条件的
        * 根据条件3，若是aPbTc是符合条件的，则aPbATca也符合条件
        * 此时不要求a、b、c彻底相等
        * 当a = '',b = 'A',c = ''时, 一层层衍生出 
        * PAAT  --->    PAAAT   --->    PA...AT
        */
        // 若是P和T两边都为空，则符合条件 例如：PAT、PAAT、PAAAT、PA...AT,均符合条件
        if (pPosition == 0 && tPosition == (pats[i].length() - 2)) {
            cout << "YES" << endl;
            continue;
        } else {
            // P 和 T 之间A的个数仅有一个时
            int aCounter = tPosition - pPosition;
            if (aCounter == 1) {
                /*
                * II 类
                * 首先PAT是符合条件的
                * 根据条件2，若是xPATx也是符合条件的，x为'', 或者为仅有A组成的字符串，
                * 由此衍生出
                * APATA --->    AAPATAA --->    AAAPATAAA   --->    A...APATA...A
                */
                // P和T之间只有一个A时，判断左右两边位数是否同样，且全为A，例如：APATA、AAPATAA、AAAPATAAA、A...APATA...A
                if (pPosition == (pats[i].length() - tPosition - 2)) {
                    bool flag = true;
                    // P左边是否全为A
                    for (int j = 0; j < pPosition; j++) {
                        if (pats[i][j] != 'A') {
                            flag = false;
                            break;
                        }
                    }
                    // T右边是否全为A
                    for (int j = pats[i].length() - 1; j > tPosition + 1; j--) {
                        if (pats[i][j] != 'A') {
                            flag = false;
                            break;
                        }
                    }
                    // 位数相同且所有为A
                    if (flag) {
                        cout << "YES" << endl;
                    } else {
                        cout << isRight << endl;
                    }
                } else {
                    cout << isRight << endl;
                }
                /* 
                * III 类
                * 根据条件3，若是aPbTc是符合条件的，则aPbATca也符合条件
                * 此时不要求a、b、c彻底相等
                * 根据II类的字符串
                * 由APATA一层层衍生出 (此时 a = 'A', b = 'A', c = 'A')
                *   aPbTc       --->        aPbATca
                *   APATA       --->        APAATAA
                *   APAATAA     --->        APAAATAAA
                * 
                * 由AAPATAA一层层衍生出 (此时 a = 'AA', b = 'A', c = 'AA')
                *   aPbTc       --->        aPbATca
                *   AAPATAA     --->        AAPAATAAAA
                *   AAPAATAAAA  --->        AAPAAATAAAAAA
                */
                //P和T之间不止一个A时
            } else {
                bool flag = true;
                // P左边是否全为A
                for (int j = 0; j < pPosition; j++) {
                    if (pats[i][j] != 'A') {
                        flag = false;
                        break;
                    }
                }
                if (!flag) {
                    cout << isRight << endl;
                    continue;
                }
                // T右边是否全为A
                for (int j = pats[i].length() - 1; j > tPosition + 1; j--) {
                    if (pats[i][j] != 'A') {
                        flag = false;
                        break;
                    }
                }
                // 位数相同且所有为A
                if (!flag) {
                    cout << isRight << endl;
                    continue;
                }
                // 渐渐发现，只要P左边A的数量 乘以 P和T之间A的数量 等于 P右边的数量也符合条件，即第III类
                int leftANumber = pPosition;
                int rightANumber = pats[i].length() - tPosition - 2;
                if (leftANumber * aCounter == rightANumber) {
                    cout << "YES" << endl;
                } else {
                    cout << isRight << endl;
                }
            }
        }
    }
    return 0;
}