1003 我要通过

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

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

1. 字符串中必须仅有P, A, T这三种字符，不可以包含其它字符；\

   1.任意形如 xPATx 的字符串都可以获得“答案正确”，其中 x 或者是空字符串，或者是仅由字母 A 组成的字符串；\
   2.如果 aPbTc 是正确的，那么 aPbATca 也是正确的，其中 a, b, c 均或者是空字符串，或者是仅由字母 A 组成的字符串。
   现在就请你为PAT写一个自动裁判程序，判定哪些字符串是可以获得“答案正确”的。

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

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

8
PAT
PAAT
AAPATAA
AAPAATAAAA
xPATx
PT
Whatever
APAAATAA

输出样例

YES
YES
YES
YES
NO
NO
NO
NO

分析：该题颇有技巧，写代码之前需要仔细得理解哪些字符是符合要求的，首先需要字符串中P,T只只出现过一次，P,T之间至少有一个A，其他字母全为A，其次，在PAT两端有着同样数目的A的字符串是符合要求的，再假设字母P之前的A的个数为a，P，T之间的A的个数为b，T之后的A的个数为c，若满足关系$a*b=c$，则满足要求
起初试图通过迭代的方法将所有满足要求2的字符串化为1的形式再判断，发现这样有很多不妥，且多次迭代比较复杂不利于调试，最终代码不完全正确，也找不出错误在哪里了：

import java.util.*;
public class Main{
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    String s=new String();
    s=in.nextLine();
    for(int i=0;i<n;i++){
      s=in.nextLine();
      if(jadge(s))
      System.out.println("YES");
      else
      System.out.println("NO");
    }
    in.close();
  }
  public static boolean jadge(String s){
    boolean ret=true;
    int idexP=s.indexOf('P');
    int idexT=s.indexOf('T');
    if(idexP==-1 || idexT==-1){
      ret=false;
    }


    if(ret){
        String s1;
        if(idexP>0)
         s1=String.valueOf(s.toCharArray(),0,idexP);
        else
            s1="";
        String s2=String.valueOf(s.toCharArray(),idexP+1,idexT-idexP-1);
        String s3;
        if(idexT<s.length()-1)
         s3=String.valueOf(s.toCharArray(),idexT+1,s.length()-idexT-1);
        else
            s3="";
        if(!(req(s1)&&req(s2)&&req(s3))||s2.equals(""))
            ret=false;
        else {
      if(s2.equals("A")){
//          String bP=String.valueOf(s.toCharArray(),0,idexP-1);
//          String aT=String.valueOf(s.toCharArray(),idexT+1,s.length()-1);
        if(req(s1)&&req(s3)&&s1.equals(s3))
        ret=true;
        else
            ret=false;
      }else{
//        String a=String.valueOf(s.toCharArray(),0,idexP);
//        String b=String.valueOf(s.toCharArray(),s.length()-idexP-1,s.length()-1);
        if(s.length()>=idexP+idexT+1){
              String str1=String.valueOf(s.toCharArray(),0,idexT-1);
              String str2=String.valueOf(s.toCharArray(),idexT,s.length()-idexT-idexP);
              String str=str1.concat(str2);
              if(!(jadge(str)))
                  ret=false;
          }
        }
        }
      }
    return ret;
    }
  public static boolean req(String x){
    boolean ret=false;
    if(x.length()==0){
      ret=true;
    }
    else {
    String A="";
    for(int i=0;i<x.length();i++)
    A=A.concat("A");
    if(x.equals(A))
    ret=true;
    }
    return ret;
  }
}

下面函数通过PT之间A的个数来完成判断：

import java.util.*;
public class Test{
  public static void main(String[] args){
      Scanner in=new Scanner(System.in);
      int n=in.nextInt();
      in.nextLine();
      String s;
      for(int i=0;i<n;i++) {
          s=in.nextLine();
          if(jadge(s))
              System.out.println("YES");
          else
              System.out.println("NO");
      }
      in.close();
  }
  public static boolean jadge(String s) {
      boolean ret=true;
      int indexP=s.indexOf('P');
      int indexT=s.indexOf('T');
      if(indexP==-1 || indexT==-1||indexP>indexT) {
          ret=false;
      }
      if(ret) {
          String s1,s2,s3;//s1,s2,s3分别表示P之前，P，T之间和T之后的字符串
          if(indexP==0)
              s1="";
          else
              s1=String.valueOf(s.toCharArray(),0,indexP-1);
          s2=String.valueOf(s.toCharArray(),indexP+1,indexT-indexP-1);
          if(indexT==s.length()-1)
              s3="";
          else
              s3=String.valueOf(s.toCharArray(),indexT+1,s.length()-indexT-1);
          if(!(req(s1)&&req(s2)&&req(s3))||s2.equals(""))
              ret=false;
          else {
              int a=indexP;
              int b=indexT-indexP-1;
              int c=s.length()-indexT-1;
              if(a*b!=c)
                  ret=false;
          }
      }
      return ret;
  }
  public static boolean req(String x){
        boolean ret=false;
        if(x.length()==0){
          ret=true;
        }
        else {
        String A="";
        for(int i=0;i<x.length();i++)
        A=A.concat("A");
        if(x.equals(A))
        ret=true;
        }
        return ret;
      }
}