[PAT A1093 1093 Count PAT‘s]

[PAT A1093 1093 Count PAT's]

 

Description:

The string APPAPT contains two PAT's as substrings. The first one is formed by the 2nd, the 4th, and the 6th characters, and the second one is formed by the 3rd, the 4th, and the 6th characters.

Now given any string, you are supposed to tell the number of PAT's contained in the string.

Input Specification:

Each input file contains one test case. For each case, there is only one line giving a string of no more than 10​5​​ characters containing only P, A, or T.

Output Specification:

For each test case, print in one line the number of PAT's contained in the string. Since the result may be a huge number, you only have to output the result moded by 1000000007.

Sample Input:

APPAPT

Sample Output:

2

CODE 

算法1：

暴力求解，三个for循环，时间复杂度为N的三次方

#include <cstdio>
#include <cstring>
const int maxn=1000000000;
char buffer[maxn];
 int main(){
     scanf("%s",buffer);
     int len=strlen(buffer);
     long long cnt=0;
     for(int i=0;i<len;i++){
         if(buffer[i]!='P')
             continue;
         for(int j=i+1;j<len;j++){
            if(buffer[j]!='A')
                continue;
             for(int k=j+1;k<len;k++){
                if(buffer[k]=='T'){
                cnt++;
                cnt=cnt%1000000007;
                }
             }
         }
     }
     printf("%lld",cnt);
     return 0;
 }

超时：

 

算法2：

考虑PAT三个字符，在一个串中，若当前字符为A，那么此时可能的PAT组合数为：当前位置左边的P个数*当前位置右边T的个数，虽然仍有三个for循环，但内部的两个总共遍历一次，时间复杂度为N的二次方

#include <cstdio>
#include <cstring>
const int maxn=1000000000;
char buffer[maxn];
 int main(){
     scanf("%s",buffer);
     int len=strlen(buffer);
     long long cnt=0;
     for(int i=0;i<len;i++){
         if(buffer[i]=='A'){
             int cntp=0,cntt=0;
             for(int j=0;j<i;j++){
                 if(buffer[j]=='P')
                     cntp++;
             }
             if(cntp==0)continue;
             for(int j=i+1;j<len;j++){
                 if(buffer[j]=='T')
                     cntt++;
             }
             if(cntt==0)continue;
             cnt+=cntp*cntt;
             cnt=cnt%1000000007;
         }
     }
     printf("%lld",cnt);
     return 0;
 }

依旧超时：

算法三：

考虑在算法二的基础上，使用一个数组存储各个字符A左边字符P的个数；然后再从尾到头得到A右边T的个数，同时计数。

#include <cstdio>
#include <cstring>
const int maxn=100001;
char buffer[maxn];
int cntp[maxn]={0};
int cntt=0;

 int main(){
     scanf("%s",buffer);
     int len=strlen(buffer);
     long long cnt=0;
     for(int i=0;i<len;i++){
         if(buffer[i]=='P'){
             if(i==0)
                 cntp[0]=1;
             else
                 buffer[i]=buffer[i-1]+1;
         }else{
             if(i==0)
                 buffer[0]=0;
             else
                 buffer[i]=buffer[i-1];
         }
     }
     for(int j=len-1;j>0;j--){
         if(buffer[j]=='T'){
             cntt++;
             continue;
         }
         if(buffer[j]=='A'){
             cnt+=cntp[j]*cntt;
             cnt=cnt%1000000007;
         }
     }
     printf("%lld",cnt);
     return 0;
 }

结果OK：

 

易错点：

以上优化思想来自算法笔记：

1.这个换个角度看A左边有多少个P，右边有多少个T确实厉害

2.用空间换时间，提前记录好P的个数（打表思想）