POJ 3280 Cheapest Palindrome ( 区间DP && 经典模型 )

题意 : 给出一个由 n 中字母组成的长度为 m 的串，给出 n 种字母添加和删除花费的代价，求让给出的串变成回文串的代价。

分析 :

原始模型 ==> 题意和本题差不多，有添和删但是并无代价之分，要求最少操作几次才能是其变成回文串

① 其实细想之后就会发现如果没有代价之分的话删除和增添其实是一样的，那么除了原串原本拥有的最长回文串不用进行考虑处理，其他都需要进行删除或者增添来使得原串变成回文串，所以只要对原串 S 和其反向串 S' 找出两者的最长公共子串长度 L 再用总长减去 L 即可

② 也可以用区间DP 思想进行求解

定义 dp[ i ][ j ] 为区间 [ i, j ] 的最少操作次数，初始化 dp[ i ][ i ] = 0

如果 str[ i ] == str[ j ]，则当前区间 [ i, j ] 的数字可从区间 [ i+1, j-1 ] 转移而来，即 dp[i][j] = dp[i+1][j-1]

如果 str[ i ] ! = str[ j ]，现只考虑删除操作那么必定要删除左右边界的一个故 dp[i][j] = min( dp[i+1][j], dp[i][j-1] ) + 1

现在看回这题，这题对具体的添加和删除操作都附上了相应的权值，其实只要对上述解法②稍加修改即可

dp[ i ][ j ] 和上面的定义一样，初始化 dp[ i ][ i ] = 0

如果 str[ i ] == str[ j ]，依旧是 dp[i][j] = dp[i+1][j-1]

如果 str[ i ] ! = str[ j ]

此时还是从 dp[i+1][j] 和 dp[i][j-1] 转移到 dp[i][j]

由于有增删区别存在，自然想到取最小，可得下面的转移方程

dp[i][j] = min( dp[i+1][j]+min( delete or add str[i] ) , dp[i][j-1]+min( delete or add str[j] ) )

具体编程的时候枚举区间长度为 dp 的阶段、然后再枚举当前长度下的每一个子串

#include<bits/stdc++.h>
using namespace std;
const int maxn = 2e3 + 10;
int dp[maxn][maxn], ADD[30], DEL[30];
char str[maxn];

int main(void)
{
    int N, M;
    while(~scanf("%d %d %s", &N, &M, str)){

        memset(ADD, 0, sizeof(ADD));
        memset(DEL, 0, sizeof(DEL));

        char ch;
        while(N--){
            scanf(" %c", &ch);
            scanf("%d %d", &ADD[ch-'a'], &DEL[ch-'a']);
            //printf("%c %d %d
", ch, ADD[ch-'a'], DEL[ch-'a']);
        }

        for(int i=1; i<=M; i++)
            dp[i][i] = 0;

        for(int i=1; i<M; i++)
            for(int j=0; j+i<M; j++)
                if(str[j] == str[j+i]) dp[j][j+i] = dp[j+1][j+i-1];
                else{
                    int temp1 = dp[j+1][j+i] + min(ADD[str[j]-'a'], DEL[str[j]-'a']);
                    int temp2 = dp[j][j+i-1] + min(ADD[str[j+i]-'a'], DEL[str[j+i]-'a']);
                    dp[j][j+i] = min(temp1, temp2);
                }

        printf("%d
", dp[0][M-1]);
    }
    return 0;
}

View Code

为什么这样的转移是对的？貌似还是太抽象，下面用样例来跑一下这个 DP

N = 3、M = 4
abcb
a 1000 1100
b 350 700
c 200 800

根据程序有以下结果

长度 == 1

dp[0][1] => a != b => 添 b 代价较小 => dp[0][1] = 350 意义为 "bab" ( 添b了)

dp[1][2] => b != c => 添 c => dp[1][2] = 200 表示 "cbc"

dp[2][3] => c != b => 添 c => dp[2][3] = 200 表示 "cbc"

长度 == 2

dp[0][2] => a != c => 添 c => dp[0][1] + 200 = 550 表示 "cbabc" ( 注意 dp[0][1] 已经变了 )

dp[1][3] => b == b => dp[2][2] = 0 表示 "bcb"

长度 == 3

dp[0][3] => a != b => 添 b => dp[0][2] + 350 = 900 表示 "bcbabcb"

上述的添xx 其实是经过了四个值的比较，看程序就知道。

比如最后的 dp[0][3] 实际是比添 a 更加优，如果添 a 的话那么就变成 dp[1][3] + 1000 = 1000 意义是 "abcba"