最长回文子序列的java解法

方法一：中心法（非常简单，易于理解）

public class Solution {
    public String longestPalindrome(String s) {
        char[] ch = s.toCharArray();
		String str = " ";
		String re = "";
		if(s.length()==0) return null;
		if(s.length()==1) return s;
		for (int i = 0; i < ch.length; i++) {
			re = getEvery(ch, i, i); // 当以一个字符为中轴也就是回文串为奇数时
			if (re.length() > str.length()) {
				str = re;
			}
			re = getEvery(ch, i, i + 1); // 当以当前和他后一个字符为轴心，也就是回文串为偶数时
			if (re.length() > str.length()) {
				str = re;
			}
		}
		return str;
	}

	public static String getEvery(char[] ch, int i, int j) {
		int length = ch.length;
		while (i >= 0 && j <= length - 1 && ch[i] == ch[j]) {
			i--;
			j++;
		}
		return String.valueOf(ch).substring(i + 1, j);
    }
}

方法二：动态规划算法

动态规划算法的一般步骤

1.找最优子结构

2.根据最优子结构写出状态转移方程

它的适用条件：动态规划适用于问题依赖于子问题的解，而子问题又有重叠子问题，它是由局部最优达到全局最优，与贪心不同的是贪心的局部最优未必能达到全局最优，下面

动态规划来实现求最长回文子序列

动态规划方程如下：

1.dp[i][j] 表示子串s[i…j]是否是回文初始化：dp[i][i] = true (0 <= i <= n-1);  

2.dp[i][i-1] = true (1 <= i <= n-1); 其余的初始化为false

3.dp[i][j] = (s[i] == s[j] && dp[i+1][j-1] == true)判断i右边和j左边的是否相同如aadaf这种情况

class Solution {
    static String longestPalindrome(String s) {
        int len = s.length();
     
        if (len <= 1)
            return s;
        boolean[][] dp = new boolean[len][len];// dp[i][j]表示s[i..j]是否是回文

        int resLeft = 0, resRight = 0;
        dp[0][0] = true;
        for (int i = 1; i < len; i++) {
            dp[i][i] = true;
            dp[i][i - 1] = true;// 这个初始化容易忽略，当k=2时要用到，例如如果字符为串为addf，s[1]==s[2]但是dp[2][1]不为真，这样下面的if语句无法执行这种情况进适合于最后有两个相连字符串的判断
        }
        for (int k = 2; k <= len; k++)
            // 枚举子串长度
            for (int i = 0; i <= len - k; i++)// 枚举子串起始位置
            {
                if (s.charAt(i) == s.charAt(i + k - 1) && dp[i+1][i+k-2])
                {
                    dp[i][i + k - 1] = true;//如果s[i]==s[i+k-1]给对应的dp里面相应的位置置为true,这里true主要是来判断字符相等的
                    if (resRight - resLeft + 1 < k) {
                        resLeft = i;
                        resRight = i + k - 1;
                    }
                }
            }
        return s.substring(resLeft, resRight + 1);
    }

    public static void main(String[] args) {
        System.out.println(longestPalindrome("aada"));
    }
};