hdu 3613 Best Reward （manachar算法）

Best Reward

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)

Problem Description

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.

 

Input

The 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.

 

Output

Output 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

　　　　　求能够得到的最大价值是多少。

解题思路：

　　　　　先算出这串项链的价值前缀和，然后用manachar算法求出项链的p数组，根据p数组枚举切割点，从而求得最大价值。

　　　　　manachar算法的具体讲解参考：http://www.cnblogs.com/yoke/p/6938193.html

AC代码：

 #include <stdio.h>
 #include <string.h>
 #include <algorithm>
 using namespace std;

 const int N = ;
 char s[N*];  // 项链
 int val[], p[N*], sum[N];  // val存每种宝石的价值  sum存项链的价值前缀和（前i个字符价值和）
 int pre[N], pos[N];   // pre标记前i个字符为回文串  pos标记后i个字符为回文串
 int manachar ()
 {
     memset(pos,,sizeof(pos));
     memset(pre,,sizeof(pre));
     memset(sum,,sizeof(sum));
     int i, j = ;
     int len = strlen(s);
     for (i = ; i <= len; i ++)   // 求项链价值的前缀和
         sum[i] += sum[i-]+val[s[i-]-'a'];

     for (i = len; i >= ; i --)  // 预处理项链字符串
     {
         s[i*+] = s[i];
         s[i*+] = '#';
     }s[] = '@';
 //    puts(s);

     int id = , mx = ;
     for (i = ; s[i]; i ++)
     {
         p[i] = i<mx? min(p[id*-i],mx-i) : ;
         while (s[i+p[i]] == s[i-p[i]]) p[i] ++;
         if (i+p[i] > mx){
             id = i;
             mx = i + p[i];
         }
         if (i == p[i]) pre[p[i]-] = ;   //表示前缀(前p[i]-1个字符)是回文串
         if (i+p[i] == *len+) pos[p[i]-] = ;   //表示后缀(后p[i]-1个字符)是回文串
     }
     int ans = -0x3f3f3f3f;
     for (i = ; i < len; i ++)  // 不断枚举切割点 求最大价值
     {
         j = ;
         if (pre[i]) j += sum[i];
         if (pos[len-i]) j += sum[len]-sum[i];
         if (j > ans) ans = j;
     }
     return ans;
 }
 int main ()
 {
     int t,i;
     scanf("%d",&t);
     while (t --)
     {
         for (i = ; i < ; i ++)
             scanf("%d",&val[i]);
         scanf("%s",s);
         int ans = manachar();
         printf("%d\n",ans);
     }
     return ;
 }