leetcode-5-最长回文子串

问题：

方法一：中心扩散方方法

package com.example.demo;

import java.util.jar.JarEntry;

public class Test05 {

    public static void main(String[] args) {
        findMedianSortedArrays("o2o2o1o2o2oaaaaaaaaaaaaa");
    }

    /**
     * 寻找字符串中的最长回文子串
     * 中心扩散法选择一个位置作为回文字符串的中心，比较中心两边的字符是否相等（需要区分两种情况，中心是一个字符和不是一个字符）
     */
    private static void findMedianSortedArrays(String s) {
        int len = s.length();
        if (len == 0) {
            System.out.println("无回文字符串");
        }

        int longtestpalindrome = 0;
        String longestPalidromeStr = "";
        // 中心点充开头开始向后移动
        for (int i = 0; i < len; i++) {
            //中心是一个字符（回文字符串长度为奇数）
            String lenEven = centerSpread(s, i, i);
            String lenOdd = centerSpread(s, i, i + 1);
            String maxStr = lenEven.length() > lenOdd.length() ? lenEven : lenOdd;
            if (maxStr.length() > longtestpalindrome) {
                longestPalidromeStr = maxStr;
                longtestpalindrome = maxStr.length();
            }

        }
        System.out.println(longestPalidromeStr + ":" + longtestpalindrome);

    }

    /**
     * 中心扩展提交中心两侧的位置，返回符合条件的长度
     */
    private static String centerSpread(String str, int left, int right) {
        int l = left, r = right;
        while (l >= 0 && r < str.length() && str.charAt(l) == str.charAt(r)) {
            l--;
            r++;
        }
        return str.substring(l + 1, r);
    }

}

方法二：动态规划

 public static void main(String[] args) {
        findMedianSortedArrays1("ac");
    }

    /**
     * 动态规划（适合问题重叠子问题，最优子结构）
     * 1、定义状态
     * 2、找到状态转义方程
     * s[i][j]：表示i到j之间字符串，左闭右闭
     * dp[i][j]：一个二位数组，使用true，false来表示s[i][j]是否是是回文序列
     * 当判断dp[i][j]是否是回文序列时，即s[i] == s[j]时，只需要判断dp[i+1][j-1]是否是回文序列
     * 　　ps：当 j - i < 2 时，表示s[i][j]中只有1个或没有元素，此时必定是回文，不需要判断dp[i+1][j-1]是否是回文序列了
　　　* 状态转义方程： dp[i][j] = s[i] == s[j] && ( j - i <= 2 || dp[i + 1][j - 1])
     *
     * @param s
     */
    private static String findMedianSortedArrays1(String s) {
        int len = s.length();
        if (len <= 1) {
            return s;
        }

        int longestPalidrome = 1;
        String longestPalidromeStr = s.substring(0, 1);
        boolean[][] dp = new boolean[len][len];
        //right从索引1出开始向有移动
        for (int right = 1; right < len; right++) {
            for (int left = 0; left < right; left++) {
                //状态转义方程
                if (s.charAt(right) == s.charAt(left) && (right - left <= 2 || dp[left + 1][right - 1])) {
                    dp[left][right] = true;
                    if (longestPalidrome < (right - left + 1)) {
                        longestPalidromeStr = s.substring(left, right + 1);
                        longestPalidrome = right - left + 1;
                    }
                }
            }
        }
        System.out.println(longestPalidromeStr + ":" + longestPalidrome);

        return longestPalidromeStr;
    }