CodeForces 150D

区间dp
gg[i][j]表示区间[i,j]全部消除的最大权
dp[i][j][k]表示区间[i,j]最后剩余一个长度为k的回文串其余全部消除的最大权

#include<cstdio>
#include<iostream>
#include<cstring>
using namespace std;
const int N=155;
int gg[N][N];
int dp[N][N][N];
int aa[N];
char ss[N];
int mx[N];

int main(){
    #ifdef DouBi
    freopen("in.cpp","r",stdin);
    #endif // DouBi
    int n;
    while(scanf("%d",&n)!=EOF){
        for(int i=1;i<=n;i++)scanf("%d",&aa[i]);
        scanf("%s",ss);
        memset(dp,-1,sizeof(dp));
        memset(gg,-1,sizeof(gg));
        for(int i=n-1;i>=0;i--){
            for(int j=i;j<n;j++){
                for(int k=1;k<=j-i+1;k++){
                    if(ss[i]==ss[j]){
                        if(k==2&&(i==j-1||gg[i+1][j-1]>=0)){
                            if(i<j-1)dp[i][j][k]=max(dp[i][j][k],
                                                    gg[i+1][j-1]);
                            else dp[i][j][k]=0;
                        }
                        if(k>2&&dp[i+1][j-1][k-2]>=0){
                            dp[i][j][k]=max(dp[i][j][k],
                                            dp[i+1][j-1][k-2]);
                        }
                        if(k==1){
                            if(i==j)dp[i][j][1]=0;
                            else {
                                dp[i][j][1]=max(gg[i][j-1],gg[i+1][j]);
                            }
                        }
                    }
                    for(int x=i;x<j;x++){
                        if(dp[i][x][k]>=0&&gg[x+1][j]>=0){
                            dp[i][j][k]=max(dp[i][j][k],
                                            dp[i][x][k]+gg[x+1][j]);
                        }
                        if(gg[i][x]>=0&&dp[x+1][j][k]>=0){
                            dp[i][j][k]=max(dp[i][j][k],
                                            gg[i][x]+dp[x+1][j][k]);
                        }
                    }
                    if(dp[i][j][k]>=0&&aa[k]>=0){
                        gg[i][j]=max(gg[i][j],dp[i][j][k]+aa[k]);
                    }
                }
            }
        }
        memset(mx,0,sizeof(mx));
        for(int i=0;i<n;i++){
            for(int j=0;j<=i;j++){
                mx[i]=max(mx[i],(j?mx[j-1]:0)+(gg[j][i]>=0?gg[j][i]:0));
            }
        }
        printf("%d\n",mx[n-1]);
    }
    return 0;
}