最长回文子串——LeeCode

 自己实现的代码，想错了，知道用动态规划，最后得出的结果是字符串正序、反序的最长公共子串，不一定是回文串:

    public static String longestPalindrome1(String s) {
        char[] PositiveOrder = s.toCharArray();
        char[] ReverseOrder = new char[s.length()];
        for (int i = 0; i < s.length(); i++) {
            ReverseOrder[i] = s.charAt(s.length() - 1 - i);
        }
        return longestPalindrome(PositiveOrder,ReverseOrder,s.length() - 1,s.length() -1);
    }

    //这个能得出字符串正序和反序的最长公共子串，最长公共子串不一定是回文串 例如:"aacabdkacaa" 它的反序是 "aacakdbacaa" 最长公共子串是aaca 最大回文串是 aca
    //需要剔除不是回文串的最大公共子串
    public static String longestPalindrome(char[] PositiveOrder, char[] ReverseOrder, int m, int n) {
        String temp = "";
        while (m > -1 && n > -1) {
            if (PositiveOrder[m] == ReverseOrder[n]) {
                temp = PositiveOrder[m] + temp;
                m--;
                n--;
            } else {
                break;
            }
        }

        //两种，一种是一直相等减下来，一种是递归进来 用temp的长度来判断
//        if (m == -1) {
            if (temp.isEmpty()){ // 递归进来的
                return "";
            }else { // 从上面减下来的
                return temp;
            }
//            return temp;
//        }
//
//        if (n == -1) {
            if (temp.isEmpty()){

            }else {

            }
//            return temp;
//        }

        //上面注释的一大堆逻辑精简为下面三行
        if (m == -1 || n == -1) {
            return temp;
        }

        String mStr = longestPalindrome(PositiveOrder,ReverseOrder,m - 1,n);
        String nStr = longestPalindrome(PositiveOrder,ReverseOrder,m,n - 1);

        if (mStr.length() > nStr.length()){
            if (temp.length() > mStr.length()){
                return temp;
            }else {
                return mStr;
            }
        }else {
            if (temp.length() > nStr.length()){
                return temp;
            }else {
                return nStr;
            }
        }

    }

看题解的：

    //动态规划先求最大公共子串，然后从最大公共子串中剔除不是回文串的
    public static String longestPalindrome(String s) {
        String origin = s;
        String reverse = new StringBuffer(s).reverse().toString();
        int length = s.length();
        int maxStrLength = 0;
        int maxStrEnd = 0;
        int[][] arr = new int[length][length];
        for (int i = 0; i < length; i++) {
            for (int j = 0; j < length; j++) {
                if (origin.charAt(i) == reverse.charAt(j)){
                    if (i == 0 || j == 0){
                        arr[i][j] = 1;
                    }else {
                        arr[i][j] = arr[i - 1][j - 1] + 1;
                    }
                }

                if (arr[i][j] > maxStrLength){ // 判断是不是回文串，
                    int first = length - 1 - j;
                    if (first + arr[i][j] - 1 == i){
                        maxStrLength = arr[i][j];
                        maxStrEnd = i;
                    }
                }
            }
        }
        return s.substring(maxStrEnd - maxStrLength + 1,maxStrEnd + 1);
    }

从最长公共子串中剔除不是回文串的思路:

首先i和j都是指向的正序和倒序最后一个字符，判断反转后的子串的最后一个字符的索引j，通过计算得到反转前的索引，如果等于i能对得上就是回文串，如果不等于i对不上就不是回文串。

因为每一次一样的字符，都要判断是不是回文，所以只用判断最后一个字符