腾讯2017暑期实习生编程题--构造回文

给定一个字符串s，你可以从中删除一些字符，使得剩下的串是一个回文串。如何删除才能使得回文串最长呢？输出需要删除的字符个数。

输入描述:

输入数据有多组，每组包含一个字符串s，且保证:1<=s.length<=1000.

输出描述:

对于每组数据，输出一个整数，代表最少需要删除的字符个数。

示例1

输入

abcda
google

输出

2
2

思路：动态规划

方法一:求最长回文子序列，再用整个字符串长度减去最长回文子序列长度。
设字符串为s，f(i,j)表示s[i..j]的最长回文子序列。
状态转移方程如下：
当i > j时，f(i,j)=0
当i = j时，f(i,j)=1
当i < j并且s[i]=s[j]时，f(i,j)=f(i+1,j-1)+2
当i < j并且s[i]≠s[j]时，f(i,j)=max( f(i,j-1), f(i+1,j) )
具体实现起来，初始化特殊情况后，两层for循环，第一层循环变量记录回文长度，第二层循环变量记录起始索引位置。

#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
int solution(string s){
    int result;
        int n=s.length();
        int dp[n][n];
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                dp[i][j]=0;
            }
        }
        for(int j=0;j<n;j++){
            dp[j][j]=1;
        }
        for(int j=1;j<n;j++){
            for(int k=0;k<n-j;k++){
                if(s[k]==s[k+j]){
                     dp[k][k+j]=dp[k+1][k+j-1]+2;
                }
                else{
                     dp[k][k+j]=max(dp[k+1][k+j],dp[k][k+j-1]);
                }
            }
        }
        result=n-dp[0][n-1];
    return result;
}
int main(){
    string s;
    while(cin>>s){
        cout<<solution(s)<<endl;
    }
    return 0;
}

方法二：求最长公共子序列，再用整个字符串长度减去最长公共子序列长度。这里的最长公共子序列指的是原字符串和将其逆转后的反串之间的。
序列str1和序列str2
长度分别为m和n
创建1个二维数组L[m.n]
初始化L数组内容为0
m和n分别从0开始循环，m++，n++
如果str1[m] == str2[n]，则L[m,n] = L[m - 1, n -1] + 1
如果str1[m] != str2[n]，则L[m,n] = max{L[m,n - 1]，L[m - 1, n]}
最后L[m,n]中的数字一定是最大的，且这个数字就是最长公共子序列的长度。

#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
const int MAX = 1001;
int MaxLen[MAX][MAX]; 
int maxLen(string s1, string s2){
    int length1 = s1.size();
    int length2 = s2.size();
    for (int i = 0; i < length1; ++i)
        MaxLen[i][0] = 0;
    for (int i = 0; i < length2; ++i)
        MaxLen[0][i] = 0;

    for (int i = 1; i <= length1; ++i)
    {
        for (int j = 1; j <= length2; ++j)
        {
            if (s1[i-1] == s2[j-1]){
                MaxLen[i][j] = MaxLen[i-1][j - 1] + 1;
            }
            else
            {
                MaxLen[i][j] = max(MaxLen[i - 1][j], MaxLen[i][j - 1]);
            }
        }
    }

    return MaxLen[length1][length2];
}

int main(){
    string s;
    while (cin >> s){
        int length = s.size();
        if (length == 1){
            cout << 1 << endl;
            continue;
        }

        string s2 = s;
        reverse(s2.begin(),s2.end());
        int max_length = maxLen(s, s2);
        cout << length - max_length << endl;
    }
    return 0;
}

拓展：最长递增子序列的长度问题可以转化为上面最长公共子序列的问题，因为原数组{5， 6， 7， 1， 2， 8}和排序后数组{1， 2， 5， 6， 7， 8}的最长公共子序列{5，6，7，8}就是原数组的最长递增子序列。

写到这里，发现加上之前leetcode上写的最长回文字串，就剩下最长公共子串没写了，两层for循环方式同上，状态转移方程如下:
如果xi == yj，则 c[i][j] = c[i-1][j-1]+1
如果xi ! = yj, 那么c[i][j] = 0
最后求Longest Common Substring的长度等于
max{ c[i][j], 1<=i<=n， 1<=j<=m}

最后，还想说一句，DP实在是太牛逼了，好多复杂的问题想通了之后，方程一写，代码就出来了！