回文串（5，131，132）

5.最长回文子串

1.动态规划

class Solution {
    public String longestPalindrome(String s) {
        //难！！
        //动态规划
        int n = s.length();
        boolean[][] dp = new boolean[n][n];//dp[i][j]表示s[i...j]是回文串！！！
        int start = 0, maxLen = 1;
        char[] str = s.toCharArray();
        //注意！！迭代方向是从短序列到长序列而不是，从左到右！！！
        for(int len = 2;len <= n;len++){//序列长度从短到长
            for(int i = 0;i < n;i++){
                int j = i + len - 1;
                if(j >= n) break;
                if(str[i] != str[j]) dp[i][j] = false;
                else if(j - i < 3)
                    dp[i][j] = true;
                else dp[i][j] = dp[i+1][j-1];
                
                if(dp[i][j] && len > maxLen){
                    start = i;
                    maxLen = len;
                }
            }
        }
        return s.substring(start, start+maxLen);
    }
}

2.中心扩散算法

class Solution {
    public String longestPalindrome(String s) {
        //中心扩散！！ 分为奇偶两种情况
        int start = 0, maxLen = 1;
        int n = s.length();
        for(int i = 0;i < n;i++){
            int len1 = expandAroundCenter(s, i, i);//奇数
            int len2 = expandAroundCenter(s, i, i+1);//偶数
            int len = Math.max(len1, len2);
            if(len > maxLen){
                maxLen = len;
                start = i - (maxLen-1)/2;	//注意计算起始位置
            }
        }
        return s.substring(start, start+maxLen);
    }
    public int expandAroundCenter(String s, int left, int right){
        while(left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)){
            left--;right++;
        }
        return right - left - 1;//注意！！此处的left和right必不满足s.charAt(left) == s.charAt(right)
    }
}

3. 马拉车算法

131.分割回文串

动规+回溯！

class Solution {
    boolean[][] dp;
    List<List<String>> ans = new ArrayList<>();
    List<String> ls = new ArrayList<>();
    int n;
    public List<List<String>> partition(String s) {
        //动态规划+回溯！！
        n = s.length();//千万不能写int n!!!
        dp = new boolean[n][n];//dp[i][j]表示s[i...j]是否是回文串
        
        for(int i = 0;i < n;i++){
            Arrays.fill(dp[i], true);//全部设为true
        }

        
        for(int i = n-1;i >= 0;i--){//这里i必须是从大到小，因为长串会利用短串的结果
            for(int j = i+1;j < n;j++){
                dp[i][j] = (s.charAt(i) == s.charAt(j)) && dp[i+1][j-1];
            }
        }
        
        backTrace(s, 0);
        return ans;
    }
    public void backTrace(String s, int start){
        if(start == n){
            ans.add(new ArrayList<String>(ls));
            return;
        }

        for(int end = start;end < n;end++){
            if(dp[start][end]){
                ls.add(s.substring(start, end+1));
                backTrace(s, end+1);
                ls.remove(ls.size()-1);
            }
        }
    }
}

132.分割回文串Ⅱ

双动规

class Solution {
    public int minCut(String s) {
        //双动规
        int n = s.length();
        boolean[][] dp = new boolean[n][n];
        for(int i = 0;i < n;i++){
            Arrays.fill(dp[i], true);
        }
        for(int i = n-1;i >= 0;i--){
            for(int j = i+1;j < n;j++){
                dp[i][j] = (s.charAt(i) == s.charAt(j)) && dp[i+1][j-1];
            }
        }

        int[] f = new int[n];//f[i]表示s[0...i]的最少分割次数
        Arrays.fill(f, Integer.MAX_VALUE);
        f[0] = 0;
        for(int i = 1;i < n;i++){
            if(dp[0][i]){
                f[i] = 0;//f[i]代表s[0...i]
            }
            else{
                for(int j = 0;j < i;j++){
                    if(dp[j+1][i])//s[j+1...i]是回文串
                        f[i] = Math.min(f[i], f[j]+1);
                }
            }
        }
        return f[n-1];
    }
}