PAT 1003.我要通过1

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

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

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

现在就请你为 PAT 写一个自动裁判程序，判定哪些字符串是可以获得“答案正确”的。

输入格式：

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

输出格式：

每个字符串的检测结果占一行，如果该字符串可以获得“答案正确”，则输出 YES，否则输出 NO。

输入样例：

8
PAT
PAAT
AAPATAA
AAPAATAAAA
xPATx
PT
Whatever
APAAATAA

输出样例：

YES
YES
YES
YES
NO
NO
NO
NO

 using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 
 namespace ConsoleApp5
 {
     class Program
     {
         static void Main(string[] args)
         {
             /*字符串中只能含有PAT，1个P，1个T，多个A，且P一定在T前，PT直接至少一个A
              * xPATx是正确的,(x为空串或者A)
              * 条件3基于条件2，若aPbTc is right,那么aPAbTca 也是right
              * 假设A(n),B(n),C(n),为n次递归后含有A的个数
              * 基于条件2
              * 根据条件得A(1)=C(1),B(1)=1
              * 根据条件3
              * A(n)=A(1),B(n)=B(n-1)+1,C(n)=C(n-1)+A(1)
              * 解的
              * A(n)=A(1)
              * B(n)=B(1)+(n-1)=1+n-1=n
              * C(n)=C(1)+(n-1)*A(1)=n*A(1)
              * =>A(n)*B(n)=C(n)
              */
 
             int count = ;
             //输入一个数值，表示要测试多少个用例
             count = Convert.ToInt32(Console.ReadLine());
             //存放输入的用例
             string[] strIn = new string[count];
             //存放YES or NO
             string[] strOut = new string[count];
             //输入用例并存放在strIn数组中
             for (int i = ; i < count; i++)
             {
                 strIn[i] = Console.ReadLine();
             }
 
             //对用例进行判断
             for (int i = ; i < count; i++)
             {
                 //获取用例中"P"，"T"的个数
                 int pnumber = Regex.Matches(strIn[i], "P").Count;
                 int tnumber = Regex.Matches(strIn[i], "T").Count;
                 //获取用例中"P""T"的下标
                 int indexP = strIn[i].IndexOf("P");
                 int indexT = strIn[i].IndexOf("T");
                 //判断用例是否只含有PAT三种字符
                 for (int j = ; j < strIn[i].Length; j++)
                 {
                     if (strIn[i][j]!='A'&& strIn[i][j] != 'P' && strIn[i][j] != 'T' )
                     {
                         strOut[i] = "NO";
                     }
                     //筛选出只含有PAT字符的字符串
                     else
                     {
                         //筛选出P,T个数只为1的字符串
                         if (pnumber ==  && tnumber == )
                         {
                             //P在A前面
                             if (indexP < indexT)
                             {
                                 //获取lengtha,lengthb,lengthc，表示A(n),B(n),C(n)
                                 int lengtha, lengthb, lengthc;
                                 string a, b, c;
                                 a = strIn[i].Substring(, indexP + );
                                 lengtha = Regex.Matches(a, "A").Count;
 
                                 b = strIn[i].Substring(indexP + , indexT - indexP - );
                                 lengthb = Regex.Matches(b, "A").Count;
 
                                 c = strIn[i].Substring(indexT + );
                                 lengthc = Regex.Matches(c, "A").Count;
                                 //排除PT直接没有A的字符串
                                 if (lengthb==)
                                 {
                                     strOut[i] = "NO";
                                     break;
                                     ;
                                 }
                                 //满足条件A(n)*B(n)=C(n)
                                 if (lengtha * lengthb == lengthc)
                                 {
                                     strOut[i] = "YES";
                                 }
                                 else
                                 {
 
                                     strOut[i] = "NO";
                                 }
 
                             }
                             else
                             {
 
                                 strOut[i] = "NO";
                             }
 
                         }
 
                         else
                         {
                             strOut[i] = "NO";
                         }
                     }
                 }
 
             }
             //输出答案
             for (int i = ; i < count; i++)
             {
                     Console.WriteLine(strOut[i]);
             }
 
             Console.ReadKey();
             }
         }
 }