见微知著----POJ 1159（线性DP问题+滚动数组）

POJ 1159 Palindrome

Description
A palindrome is a symmetrical string, that is, a string read identically from left to right as well as from right to left. You are to write a program which, given a string, determines the minimal number of characters to be inserted into the string in order to obtain a palindrome.

As an example, by inserting 2 characters, the string “Ab3bd” can be transformed into a palindrome (“dAb3bAd” or “Adb3bdA”). However, inserting fewer than 2 characters does not produce a palindrome.
Input
Your program is to read from standard input. The first line contains one integer: the length of the input string N, 3 <= N <= 5000. The second line contains one string with length N. The string is formed from uppercase letters from ‘A’ to ‘Z’, lowercase letters from ‘a’ to ‘z’ and digits from ‘0’ to ‘9’. Uppercase and lowercase letters are to be considered distinct.
Output
Your program is to write to standard output. The first line contains one integer, which is the desired minimal number.
Sample Input
5
Ab3bd
Sample Output
2

问题简介：
给定一个字符串，问最少插入多少字符，使得该字符串变成回文字符串。
问题解析：
这个问题难点有二：
（1）设X是原字符串序列，Y是X的逆序列；
最少需要补充的字母数 = X的长度 – X和Y的最长公共子序列的长度。
设X = “Ab3bd”,则Y=”db3bA”,最长公共子序列长度为3，此时最少需要补充的字母数为5-3=2
（2）难点二在于N = 5000，开静态数组int会超，而short会过，因此使用滚动数组。
就问题求LCS（最长公共子序列）而言，dp[i][j]会和dp[i-1][j],dp[i][j-1]和dp[i-1][j-1]有关。
由于DP问题的无后效性，对于某个给定的阶段状态，它以前的状态无法直接影响它未来的决策，而只能通过当前这个状态。因此就本题而言，当N为最大值5000时，开的空间为5000x5000；然而使用滚动数组可以使开的空间仅为2x5000，大大节省了空间。

代码

#include <iostream>
#include <cstring>
#include <vector>
#include <algorithm>

using namespace std;

int dp[2][5005];    //使用滚动数组，大大节省空间

int main()
{
    string s1,s2;
    int n,i,j;
    while(cin>>n){
        cin>>s1;
        s2 = s1;
        reverse(s1.begin(),s1.end());
        memset(dp,0,sizeof(dp));
        for(i=1;i<=n;i++){
            for(j=1;j<=n;j++){
                dp[i%2][j] = max(dp[(i-1)%2][j],dp[i%2][j-1]);
                if(s1[i-1] == s2[j-1])
                {
                    int temp = dp[(i-1)%2][j-1] + 1;
                    dp[i%2][j] = max(dp[i%2][j],temp);
                }
            }
        }
        cout<<n - dp[n%2][n] << endl;
    }
    return 0;
}