HDU 3613 Best Reward(KMP算法求解一个串的前、后缀回文串标记数组)

题目链接：

https://cn.vjudge.net/problem/HDU-3613

After an uphill battle, General Li won a great victory. Now the head of state decide to reward him with honor and treasures for his great exploit.

One of these treasures is a necklace made up of 26 different kinds
of gemstones, and the length of the necklace is n. (That is to say: n
gemstones are stringed together to constitute this necklace, and each of
these gemstones belongs to only one of the 26 kinds.)

In accordance with the classical view, a necklace is valuable if
and only if it is a palindrome - the necklace looks the same in either
direction. However, the necklace we mentioned above may not a palindrome
at the beginning. So the head of state decide to cut the necklace into
two part, and then give both of them to General Li.

All gemstones of the same kind has the same value (may be positive
or negative because of their quality - some kinds are beautiful while
some others may looks just like normal stones). A necklace that is
palindrom has value equal to the sum of its gemstones' value. while a
necklace that is not palindrom has value zero.

Now the problem is: how to cut the given necklace so that the sum of the two necklaces's value is greatest. Output this value.

InputThe first line of input is a single integer T (1 ≤ T ≤ 10) -
the number of test cases. The description of these test cases follows.

For each test case, the first line is 26 integers: v
₁, v
₂, ..., v
₂₆ (-100 ≤ v
_i ≤ 100, 1 ≤ i ≤ 26), represent the value of gemstones of each kind.

The second line of each test case is a string made up of charactor
'a' to 'z'. representing the necklace. Different charactor representing
different kinds of gemstones, and the value of 'a' is v
₁, the value of 'b' is v
₂, ..., and so on. The length of the string is no more than 500000.

OutputOutput a single Integer: the maximum value General Li can get from the necklace.Sample Input

2
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
aba
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
acacac

Sample Output

1
6

 /*
 题意描述
 输入26个小写字母的价值，再输入一个字符串，问从哪个位置分割开，两个串的价值之和最大，当分成的串是回文串的时候，价值是各个字母的
 和，不是回文串的时候，价值为0

 解题思路
 问题的关键是如何判断从哪个位置分割开后，前缀和后缀是不是回文串，普通的办法时间复杂度太高。
 具体做法是将原s串反转赋值给t，拿s去匹配t，跑一遍kmp，得到s串的最大前缀子串的位置temp
                         同理拿t串去匹配s，跑一边kmp，得到s串的最大后缀子串的位置temp
 由next数组的特性可知，将temp的位置标记为前缀回文后，寻找之前一个的前缀回文，也即next[temp]里面存的是之前一个前缀回文串的位置
 ，然后标记，如此循环，直到temp=0，表示没有前缀回文串，同理可得到后缀子串的回文标记数组。然后枚举每一个分割位置，判断是否时是
 回文，计算求解最大值，其中利用前缀和数组加快计算。
 */
 #include<cstdio>
 #include<cstring>

 const int maxn = ;
 const int inf=;
 char s[maxn], t[maxn];
 int val[], next[maxn], presum[maxn];
 bool pre[maxn], pos[maxn];

 void get_next(char b[], int len);
 int kmp(char a[], char b[], int len);

 int main()
 {
     int T;
     scanf("%d", &T);
     while( T-- ){
         for(int i = ; i < ; i++){
             scanf("%d", &val[i]);
         }
         scanf("%s", s);
         int len = strlen(s);
         for(int i=;i<len;++i)
         t[i] = s[len -  - i],presum[i + ] = presum[i] + val[s[i] - 'a'];
         t[len]='\0';

         memset(next,,sizeof(next));
         get_next(s,len);
         int temp=kmp(s,t,len);//拿s去匹配t，也即t是主串，s是副串
         memset(pre, , sizeof(pre));
         while(temp){
             pre[temp] = ;
             temp = next[temp];
         }

         memset(next,,sizeof(next));
         get_next(t,len);
         temp=kmp(t,s,len);
         memset(pos, , sizeof(pos));
         while(temp){
             pos[temp] = ;
             temp = next[temp];
         }

         int ans = -inf;
         for(int i = ; i < len; i++){
             int sum = ;
             if(pre[i])
                 sum += presum[i];
             if(pos[len - i])
                 sum += presum[len] - presum[i];
             if(sum > ans)
                 ans = sum;
         }
         printf("%d\n",ans);
     }
     return ;
 }

 int kmp(char a[], char b[], int len){//注意a是副串，b是主串
     int i=;
     int j=;
     while(i < len && j < len){
         if(j == - || a[j] == b[i]){
             i++;
             j++;
         }
         else
             j=next[j];
     }
     return j;//返回副串，也就是原串的最后匹配位置，故前j称为原串的最大前缀回文子串
 }

 void get_next(char a[], int len){
     int i = ;
     int j = -;
     next[] = -;
     while(i < len){
         if(j == - || a[i] == a[j]){
             i++;
             j++;
             next[i] = j;
         }
         else
             j = next[j];
     }
     /*for(int i = 1; i <= len; i++){
         printf("%d ",next[i]);
     }
     puts("");*/
 }