leetcode题解-647. Palindromic Substrings && 5. Longest Palindromic Substring

题目：

Given a string, your task is to count how many palindromic substrings in this string.

The substrings with different start indexes or end indexes are counted as different substrings even they consist of same characters.

Example 1:
Input: "abc"
Output: 3
Explanation: Three palindromic strings: "a", "b", "c".
Example 2:
Input: "aaa"
Output: 6
Explanation: Six palindromic strings: "a", "a", "a", "aa", "aa", "aaa".
Note:
The input string length won't exceed 1000.

本题的目的是寻找一个字符串中存在的回文子串的个数，很容易想到的方法是挨个字符进行遍历，然后判断以他开始的子串是否为回文字符串，但是这种方法效率太低了，我们可以转变一下想法，那就是对每个字符，我们将其作为子串的中心，然后向两侧开始扩展判断是否为回文子串，这样效率就提升了很多，而且思路可以说是非常简单清晰了、下面看代码：

    int count = 0;

    public int countSubstrings(String s) {
        if (s == null || s.length() == 0) return 0;

        for (int i = 0; i < s.length(); i++) { // i is the mid point
            extendPalindrome(s, i, i); // odd length;
            extendPalindrome(s, i, i + 1); // even length
        }

        return count;
    }

    private void extendPalindrome(String s, int left, int right) {
        while (left >=0 && right < s.length() && s.charAt(left) == s.charAt(right)) {
            count++; left--; right++;
        }
    }

此外我们还可以使用DP动态规划的方法进行求解，思路是使用一个二维数组来保存对应的两个元素是否相等，然后对dp数组的结果进行求和：

    public int countSubstrings1(String s) {
        int n = s.length();
        int res = 0;
        boolean[][] dp = new boolean[n][n];
        for (int i = n - 1; i >= 0; i--) {
            for (int j = i; j < n; j++) {
                dp[i][j] = s.charAt(i) == s.charAt(j) && (j - i < 3 || dp[i + 1][j - 1]);
                if(dp[i][j]) ++res;
            }
        }
        return res;
    }

接下来看第二道题目：

Given a string s, find the longest palindromic substring in s. You may assume that the maximum length of s is 1000.

Example:

Input: "babad"

Output: "bab"

Note: "aba" is also a valid answer.
Example:

Input: "cbbd"

Output: "bb"

这两道题目可以说是十分一样了==解题的思路也没有什么区别，也是上面两种方法，代码如下所示：

    //44.5%
    public static String longestPalindrome(String s) {
        int max = 0;
        String res="";
        for(int i=0; i<s.length(); i++){
            String tmp = help(s, i, i);
            if(tmp.length() > max){
                max = tmp.length();
                res = tmp;
            }
            tmp = help(s, i, i+1);
            if(tmp.length() > max){
                max = tmp.length();
                res = tmp;
            }
        }
        return res;
    }

    public static String help(String s, int i, int j){
        while(i>=0 && j<s.length() && s.charAt(i) == s.charAt(j)){
            i--;
            j++;
        }
            return s.substring(i+1, j);
    }

    //34%，动态规划方法
    public String longestPalindrome2(String s) {
        if(s == null || s.length() == 0) {
            return "";
        }
        int len = s.length();
        boolean[][] dp = new boolean[len][len];
        int start = 0;
        int end = 0;
        int max = 0;
        for(int i = 0; i < s.length(); i++) {
            for(int j = 0; j <= i; j++) {
                if(s.charAt(i) == s.charAt(j) && (i - j <= 2 || dp[j+1][i-1])) {
                    dp[j][i] = true;
                }
                if(dp[j][i] && max < i - j + 1) {
                    max = i - j + 1;
                    start = j;
                    end = i;
                }
            }
        }
        return s.substring(start, end + 1);
    }

但是我还找到一种可以击败97%的方法，思路就是第一种方法一样，但是效率会高很多，我也并没有找到具体的原因：

    //95%
    private int lo, maxLen;
    public String longestPalindrome1(String s) {
        int len = s.length();
        if (len < 2)
            return s;

        for (int i = 0; i < len-1; i++) {
            extendPalindrome(s, i, i);  //assume odd length, try to extend Palindrome as possible
            extendPalindrome(s, i, i+1); //assume even length.
        }
        return s.substring(lo, lo + maxLen);
    }

    private void extendPalindrome(String s, int j, int k) {
        while (j >= 0 && k < s.length() && s.charAt(j) == s.charAt(k)) {
            j--;
            k++;
        }
        if (maxLen < k - j - 1) {
            lo = j + 1;
            maxLen = k - j - 1;
        }
    }