57-动态规划-647.回文子串 516.最长回文子序列

647.回文子串

给定一个字符串，你的任务是计算这个字符串中有多少个回文子串。
具有不同开始位置或结束位置的子串，即使是由相同的字符组成，也会被视作不同的子串。
示例 1：输入：“abc” 输出：3 解释：三个回文子串: “a”, “b”, “c”
示例 2：输入：“aaa” 输出：6 解释：6个回文子串: “a”, “a”, “a”, “aa”, “aa”, “aaa”
提示：输入的字符串长度不会超过 1000 。

可以使用两种方法
动态规划：

class Solution {
    public int countSubstrings(String s) {
        //dp  [i, j]
        boolean[][] dp = new boolean[s.length()][s.length()];
        int res = 0;
        for(int i = s.length() - 1; i >= 0; i --)
            for(int j = i; j < s.length(); j ++){
                if(s.charAt(i) == s.charAt(j) 
                   && (j - i <=1 || dp[i + 1][j - 1] == true)){
                    res++;
                    dp[i][j] = true;
                }
            }
        return res;
    }
}

双指针法：

516.最长回文子序列

给定一个字符串 s ，找到其中最长的回文子序列，并返回该序列的长度。可以假设 s 的最大长度为 1000 。
示例 1: 输入: “bbbab” 输出: 4 一个可能的最长回文子序列为 “bbbb”。
示例 2: 输入:“cbbd” 输出: 2 一个可能的最长回文子序列为 “bb”。
提示：
1 <= s.length <= 1000
s 只包含小写英文字母

相等的话就+2，不想等回退一下看看哪个更大。

class Solution {
    public int longestPalindromeSubseq(String s) {
        int l = s.length();
        int[][] dp = new int[l][l];
        for(int i = l - 1 ; i >= 0; i --){
            dp[i][i] = 1;
            for(int j = i + 1; j < l; j++){
                if(s.charAt(i) == s.charAt(j)){
                    dp[i][j] = dp[i + 1][j - 1] + 2;
                }else{
                    dp[i][j] = Math.max(dp[i + 1][j], dp[i][j - 1]);
                }
            }
        }
        return dp[0][l - 1];
    }
}