最长回文子序列（不连续）以及最长回文子串（连续）

整理了一下关于回文子序列和回文子串的程序。

其中（1）和（2）是采用动态规划的思想写出的回文子序列的程序，这种子序列就是在原始的串中可以不连续，比如对于那种要求删除几个字符来得到最长的回文字符串的题就是这种情况。

比如caberbaf.  最长的子序列是5 abeba 或者abrba。而子串最长只有1

（3）（4）（5）都是最长子串的求法。（3）是暴力求解，（4）是改进的暴力求解。（5）采用的是动态规划的方法。

#include <iostream>
#include <string>
#include <vector>
#define MAX 1000
using namespace std;

/***************************************************************************************/
/***************************************************************************************/

/*(1)采用循环
最长回文子序列 （不连续地---序列，子串是连续地）
动态规划
**/
int maxPalindromeLen(string s){
    int len = s.length();
    if (len == 0)
    {
        return 0;
    }
    else if (len == 1)
    {
        return 1;
    }
    vector<int> max_Palind(len);
    //init
    for (size_t i = 0; i < len; i++)
    {
        max_Palind[i] = 0;
    }        
    max_Palind[0] = 1;

    for (int j = 0; j < len; j++)
    {
        for (int i = 0; i <j; ++i)
        {
            if (max_Palind[i]<max_Palind[i + 1] + (s[i] == s[j]) * 2){
                max_Palind[i] = max_Palind[i + 1] + (s[i] == s[j]) * 2;
            }
        }
        max_Palind[j] = 1;
    }
    return max_Palind[0];
}

/***************************************************************************************/
/***************************************************************************************/
int max(int a, int b)
{
    if (a > b)
    {
        return a;
    }
    else
    {
        return b;
    }

}
/*(2) 采用递归
最长回文子序列 （不连续地---序列，子串是连续地）
最优子结构
假设 X[0 ... n-1]  是给定的序列，长度为n.  让 L(0,n-1) 表示 序列 X[0 ... n-1] 的最长回文子序列的长度。

1. 如果X的最后一个元素和第一个元素是相同的，这时：L(0, n-1) = L(1, n-2) + 2 , 
还以 “BBABCBCAB” 为例，第一个和最后一个相同，因此 L(1,n-2) 就表示蓝色的部分。

2. 如果不相同：L(0, n-1) = MAX ( L(1, n-1) ,  L(0, n-2) )。 
以”BABCBCA” 为例，L(1,n-1)即为去掉第一个元素的子序列，L(0, n-2)为去掉最后一个元素。
*/
int lps(string &s, int i, int j)
{
    if (i == j)
    {
        return 1;
    }
    if (i > j)
    {
        return 0;
    }
    //如果首尾相同
    if (s[i] == s[j])
    {
        return lps(s, i + 1, j - 1) + 2;
    }
    //首尾不同，两种情况
    return max(lps(s, i + 1, j), lps(s, i, j - 1));
}

/***************************************************************************************/
/***************************************************************************************/

/*(3)最长回文子串(就是连续地)
暴力循环
*/
bool isPalindrome(string s)
{
    int len = s.size();
    for (int i = 0; i < len / 2; i++)
    {
        if (s[i] != s[len - i - 1])
        {
            return false;
        }
    }
    return true;
}
int maxPalindromeLength(string s)
{
    int len = s.size();
    int maxLength = 0;
    for (int i = 0; i < len - 1; i++)
    {
        for (int j = 1; j <= len - i; j++)
        {
            //构造一个子串，从i开始的j个字符
            string substr = s.substr(i, j);
            if (isPalindrome(substr))
            {
                int len = substr.size();
                if (len > maxLength)
                {
                    maxLength = len;
                }
            }
        }
    }
    return maxLength;
}

/***************************************************************************************/
/***************************************************************************************/

/*(4)改进的最长回文子串（o(n的平方)）
以中心轴进行判断
*/
int l2r(string s,int mid)
{
    int l = mid - 1, r = mid + 1;
    int len = s.size();
    while (s[mid] == s[r])//考虑那种中间相同的情况 比如abbc 相当于bb为中心
    {
        r++;
    }
    while (l >= 0 && r < len && s[l] == s[r])
    {
        l--;
        r++;
    }
    return r - l - 1;
}
int maxl2r(string s)
{
    int len = s.size();
    if (len == 0)
    {
        return 0;
    }
    else if (len == 1)
    {
        return 1;
    }
    int maxlength = 0;
    for (int i = 0; i < len; i++)
    {
        int len = l2r(s, i);
        if (maxlength < len)
        {
            maxlength = len;
        }
    }
    return maxlength;
}

/***************************************************************************************/
/***************************************************************************************/

/*(5)以动态规划的方法解决最长回文子串（连续地）
递推式表示在s[i] = s[j]情况下，如果s[i+1..j-1]是回文子串，则s[i..j]也是回文子串；
如果s[i+1..j-1]不是回文子串，则s[i..j]也不是回文子串。

初始状态：

c[i][i] = 1
c[i][i+1] = 1 if s[i] == s[i+1]
*/
int maxDynamicLength(string s)
{
    int len = s.size();
    if (len == 0)
    {
        return 0;
    }
    else if (len == 1)
    {
        return 1;
    }

    int i, length;
    int longest = 1;
    bool c[MAX][MAX] = {false};
    //init
    for (i = 0; i < len; i++)
    {
        c[i][i] = true;
    }
    for (int i = 0; i < len - 1; i++)
    {
        if (s[i] == s[i + 1])
        {
            c[i][i + 1] = true;
            longest = 2;
        }
    }

    //上面已经解决了2个字符的情况；下面从字符长度为3开始
    for (length = 3; length <= len; length++)
    {
        for (i = 0; i < len - length + 1; i++)
        {
            int j = i + length - 1;//i是字符起点索引 j是终止索引
            if (s[i] == s[j] && c[i+1][j-1])
            {
                c[i][j] = true;
                longest = length;
            }
        }
    }
    return longest;
}
string longestPalindromeDP(string s) {
    int n = s.length();

    int longestBegin = 0;

    int maxLen = 1;

    bool table[1000][1000] = { false };

    for (int i = 0; i < n; i++) {

        table[i][i] = true;   //前期的初始化

    }

    for (int i = 0; i < n - 1; i++) {

        if (s[i] == s[i + 1]) {

            table[i][i + 1] = true; //前期的初始化

            longestBegin = i;

            maxLen = 2;

        }

    }

    for (int len = 3; len <= n; len++) {

        for (int i = 0; i < n - len + 1; i++) {

            int j = i + len - 1;

            if (s[i] == s[j] && table[i + 1][j - 1]) {

                table[i][j] = true;

                longestBegin = i;

                maxLen = len;

            }

        }

    }

    return s.substr(longestBegin, maxLen);

}

/***************************************************************************************/
/***************************************************************************************/

int main(int args, char* argv[])
{
    string s;
    while (cin >> s)
    {
        int len = s.size() - 1;
        cout << maxPalindromeLength(s) << endl;
        //cout << lps(s, 0, len) << endl;
        //cout << maxl2r(s) << endl;
        //cout << maxDynamicLength(s) << endl;
        //string substr = longestPalindromeDP(s);
        //cout << substr << ":" << substr.size() << endl;
    }
    return 0;
}