Day 57 | 647. Palindromic Substrings | 516. Longest Palindromic Subsequence-CSDN博客

本文链接：https://blog.csdn.net/kyle313606922/article/details/132164712

647. Palindromic Substrings

Question Link

class Solution {
    public int countSubstrings(String s) {
        char[] charS = s.toCharArray();
        int len = s.length();
        boolean[][] dp = new boolean[len][len];
        int result = 0;
        for(int i = len-1; i >= 0; i--){
            for(int j = i; j < len; j++){
                if(charS[i] == charS[j]){
                    if(j-i <= 1){               // case 1,2
                        dp[i][j] = true;
                        result++;
                    }else if(dp[i+1][j-1]){     // case 3
                        dp[i][j] = true;
                        result++;
                    }
                }
            }
        }
        return result;
    }
}

dp[i][j]: whether a substring in the range [i, j] is a palindrome substring.
Recursive Formula
- If s[i] is different with s[j], dp[i][j] must be false.
- If s[i] is the same as s[j], there are three cases as follows:
  - Same index like i == j, s[i] and s[j] are the same character
  - The difference between i and j is 1, like aa. It is also a palindromic.
  - The difference between i and j is greater than 1, like cabac. At this time, s[i] and s[j] are already the same. Whether dp[i, j] is palindromic depends on whether dp[i+1, j-1] is palindromic.
All elements in the array should be initialized to false.
Traversal Order: According to the case 3 of recursive formula, dp[i][j] is derived from dp[i+1][j-1]. So the traversal order must be bottom to top, left to right.

516. Longest Palindromic Subsequence

Question Link

class Solution {
    public int longestPalindromeSubseq(String s) {  
        char[] charS = s.toCharArray();
        int[][] dp = new int[charS.length][charS.length];
        for(int i = 0; i < charS.length; i++) dp[i][i] = 1;

        for(int i = charS.length-1; i >= 0; i--){
            for(int j = i+1; j < charS.length; j    ++){
                if(charS[i] == charS[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][charS.length-1];
    }
}

The palindromic substring is continuous, palindromic subsequence is not continuous.
dp[i][j]: the length of the longest palindrome subsequence in the range [i, j].
Recursive Formula
- If s[i] is the same as s[j]
  - dp[i][j] = dp[i+1][j-1] + 2
- If s[i] is different with s[j]
  - The length of palindromic subsequence adding s[i] is dp[i][j-1]
  - The length of palindromic subsequence adding s[j] is dp[i+1][j]
  - Choose the larger one: dp[i][j] = max(dp[i + 1][j], dp[i][j - 1])
Array Initialization
- According to the dp[i][j] = dp[i+1][j-1] + 2, the recursive formula won’t be able to calculate the dp[i][j] when i is the same as j.
- So dp[i][j](when i == j) must be initialized to 1.
Traversal Order
- dp[i][j] is derived from dp[i + 1][j - 1]，dp[i + 1][j] and dp[i][j - 1].
- So we must traversal order must be bottom to top, left to right.
- Since dp[i][j] has already been initialized to 1 when i is the same as j. We must start from i+1 to traverse j.