力扣解法汇总5-最长回文子串

原题链接：力扣

力扣


描述：

给你一个字符串 s，找到 s 中最长的回文子串。

示例 1：

输入：s = "babad"
输出："bab"
解释："aba" 同样是符合题意的答案。

解题思路：

解决这题，我们分几步吧，第一步先写出来解法，然后再一步一步的去优化。

第一版思路：

直接递归遍历判断，先判断s是不是，

如果是则s肯定是最长的回文串；

如果s不是，那就判断递归去判断s.substring(0, s.length()-1)和s.substring(1, s.length())；

这样肯定能找到最长的回文串，但是复杂度较高，会出现运行超时的情况。

大约20个字符左右就会出现超时。

第二版优化：

我们可以发现这样一个规律，递归的时候，没必要挨个去判断。

比如abbbacabba不是回文串，我们没必要判断abbbacabb是不是，而是可以直接定位到abbbaca去判断。因为回文串的首尾一定是相同的。

第二版本我们优化完，测试发现还是超时，但是情况已经好很多了。几百个字符的时候才会触发超时。

第三版优化：

第二版未能满足要求，我们继续优化，这时我们又发现一个规律。

比如原始字符串是：ababababacbc

我们目前的最长回文串是ababababa，长度为9，那么我们就没必要去判断长度少于9的字符串了，比如acbc，cbc这样的字符都可以跳过。

第四版优化：

第三版还是时间超了。

这次失败是提示：aaaaaaaaaaaaaacaaaaaaaaaaaaaa类似于这样的字符串时间，这样的字符串判断是需要花费很长时间的，所以优化重点放在了如何判断回文串上面。

这时候我们就想有没有一次性判断的可能，有的，既然回文串从前从后读都相等，那么我们构造一个完全相反的字符串进行相同位置比对，判断一次是不是就可以了呢？

比如abacdefg，反向就是：gfedcaba，我们判断aba是不是回文的时候，只要取反向的最后三位进行一次性比对即可。

通过了，耗时2000多毫秒，有些高。

第五版优化：

第四版其实已经通过了，但是时间复杂度是O(n2)，有些高。这题应该存在O(n)的解法的。先不管这些，我们继续考虑如何优化。

我们可以从前向后遍历字符串，比如abacdeafg，找到第一个a，然后从后向前找a（map里面存a的所有位置了）找到了就返回。

这样跑下来，通过了，耗时200多毫秒。时间复杂度是O(n*log(n))，还有继续优化的空间。

第六版优化：

代码：

第一版代码未优化：

public String longestPalindrome(String s) {
        char[] chars = s.toCharArray();
        String s1 = longestPalindrome(s, s, chars, 0, chars.length - 1);
        return s1;
    }

    public String longestPalindrome(String s, String currentStr, char[] chars, int startIndex, int endIndex) {
        boolean isPaindrome = isPaindrome(s, chars, startIndex, endIndex);
        if (isPaindrome) {
            paindromeSet.add(currentStr);
            return currentStr;
        }
        String s1 = longestPalindrome(s, s.substring(startIndex, endIndex), chars, startIndex, endIndex - 1);
        String s2 = longestPalindrome(s, s.substring(startIndex + 1, endIndex + 1), chars, startIndex + 1, endIndex);
        return s1.length() > s2.length() ? s1 : s2;
    }

    /**
     * 判断是否回文子串
     *
     * @param str        原始字符串
     * @param chars
     * @param startIndex
     * @param endIndex
     * @return
     */
    public boolean isPaindrome(String str, char[] chars, int startIndex, int endIndex) {
        if ((endIndex == startIndex)) {
            return true;
        }
        if ((endIndex == (startIndex + 1) && chars[startIndex] == chars[endIndex])) {
            return true;
        }
        if (paindromeSet.contains(str)) {
            return true;
        }
        if (chars[startIndex] != chars[endIndex]) {
            return false;
        }
        //如果是回文串，则加入
        boolean isPaindrome = isPaindrome(str, chars, startIndex + 1, endIndex - 1);
        return isPaindrome;
    }

第二版优化代码：

 HashMap<Integer, List<Integer>> indexMap = new HashMap<>();
    HashSet<String> paindromeSet = new HashSet<>();

    public String longestPalindrome(String s) {
        char[] chars = s.toCharArray();
        //循环一边，得出每个字符的位置
        for (int i = 0; i < chars.length; i++) {
            int aChar = chars[i];
            List<Integer> integers = indexMap.computeIfAbsent(aChar, k -> new ArrayList<>());
            integers.add(i);
        }
        int maxLength = 0;
        String maxStr = "";
        for (Integer key : indexMap.keySet()) {
            List<Integer> integers = indexMap.get(key);
            String s1 = longestPalindrome(s, chars, integers, 0, integers.size() - 1);
            if (s1.length() > maxLength) {
                maxLength = s1.length();
                maxStr = s1;
            }

        }
        return maxStr;
    }

    public String longestPalindrome(String s, char[] chars, List<Integer> integers, int startListIndex, int endListIndex) {
        Integer startIndex = integers.get(startListIndex);
        Integer endIndex = integers.get(endListIndex);
        String currentStr = s.substring(startIndex, endIndex + 1);
        boolean isPaindrome = isPaindrome(s, currentStr, chars, startIndex, endIndex);
        if (isPaindrome) {
            return currentStr;
        }
        String s1 = longestPalindrome(s, chars, integers, startListIndex, endListIndex - 1);
        String s2 = longestPalindrome(s, chars, integers, startListIndex + 1, endListIndex);
        return s1.length() > s2.length() ? s1 : s2;
    }

    /**
     * 判断是否回文子串
     *
     * @param str        当前字符串
     * @param chars
     * @param startIndex
     * @param endIndex
     * @return
     */
    public boolean isPaindrome(String str, String currentStr, char[] chars, int startIndex, int endIndex) {
        if ((endIndex == startIndex)) {
            return true;
        }
        if ((endIndex == (startIndex + 1) && chars[startIndex] == chars[endIndex])) {
            return true;
        }
        if (paindromeSet.contains(currentStr)) {
            return true;
        }
        if (chars[startIndex] != chars[endIndex]) {
            return false;
        }
        //如果是回文串，则加入
        boolean isPaindrome = isPaindrome(str, str.substring(startIndex + 1, endIndex), chars, startIndex + 1, endIndex - 1);
        if (isPaindrome) {
            paindromeSet.add(currentStr);
        }
        return isPaindrome;
    }

第四版代码：

class Solution {
   
    HashMap<Integer, List<Integer>> indexMap = new HashMap<>();
    String reverseStr = "";
    String str = "";

    public String longestPalindrome(String s) {
        char[] chars = s.toCharArray();
        str = s;
        //循环一遍，得出每个字符的位置
        StringBuilder builder = new StringBuilder();
        for (int i = 0; i < chars.length; i++) {
            int aChar = chars[i];
            List<Integer> integers = indexMap.computeIfAbsent(aChar, k -> new ArrayList<>());
            integers.add(i);
            builder.insert(0, (char) aChar);
        }
        reverseStr = builder.toString();

        int maxLength = 0;
        String maxStr = "";
        //循环100*99次，一共有10种可能。则一共循环10W次，
        for (Integer key : indexMap.keySet()) {
            List<Integer> integers = indexMap.get(key);
            String currentStr = "";
            if (integers.size() == 1) {
                currentStr = s.substring(integers.get(0), integers.get(0) + 1);
                if (currentStr.length() > maxLength) {
                    maxLength = currentStr.length();
                    maxStr = currentStr;
                }
            } else {
                for (int i = 0; i < integers.size(); i++) {
                    Integer start = integers.get(i);
                    for (int j = i + 1; j < integers.size(); j++) {
                        currentStr = s.substring(start, integers.get(j) + 1);
                        if (currentStr.equals("cbababcbcabc")) {
//                            System.out.print("x");
                        }
                        boolean paindrome = isPaindrome(str, reverseStr, start, integers.get(j));
                        if (paindrome) {
                            if (currentStr.length() > maxLength) {
                                maxLength = currentStr.length();
                                maxStr = currentStr;
                            }
                        }
                    }
                }
            }
        }
        return maxStr;
    }

    /**
     * 判断是否回文子串
     *
     * @param str        当前字符串
     * @param startIndex
     * @param endIndex
     * @return
     */
    public boolean isPaindrome(String str, String reverseStr, int startIndex, int endIndex) {
        String substring1 = str.substring(startIndex, endIndex + 1);
        String substring2 = reverseStr.substring(str.length() - endIndex - 1, str.length() - startIndex - 1 + 1);
        return substring1.equals(substring2);
    }
}

第五版代码：

class Solution {
   HashMap<Integer, List<Integer>> indexMap = new HashMap<>();
    String reverseStr = "";
    String str = "";
    public String longestPalindrome(String s) {
        char[] chars = s.toCharArray();
        str = s;
        //循环一遍，得出每个字符的位置
        StringBuilder builder = new StringBuilder();
        for (int i = 0; i < chars.length; i++) {
            int aChar = chars[i];
            List<Integer> integers = indexMap.computeIfAbsent(aChar, k -> new ArrayList<>());
            integers.add(i);
            builder.insert(0, (char) aChar);
        }
        reverseStr = builder.toString();

        int maxLength = 0;
        String maxStr = "";
        String currentStr = "";
        for (int i = 0; i < chars.length; i++) {
            int aChar = chars[i];
            List<Integer> integers = indexMap.get(aChar);
            if (integers.size() == 1) {
                currentStr = s.substring(integers.get(0), integers.get(0) + 1);
                if (currentStr.length() > maxLength) {
                    maxLength = currentStr.length();
                    maxStr = currentStr;
                }
                continue;
            }
            for (int k = integers.size() - 1; k >= 0; k--) {
                Integer end = integers.get(k);
                if (i >= end) {
                    break;
                }
                boolean paindrome = isPaindrome(str, reverseStr, i, end);
                if (paindrome) {
                    currentStr = str.substring(i, end + 1);
                    if (currentStr.length() > maxLength) {
                        maxLength = currentStr.length();
                        maxStr = currentStr;
                    }
                    break;
                }
            }
        }
        return maxStr;
    }

    /**
     * 判断是否回文子串
     *
     * @param str        当前字符串
     * @param startIndex
     * @param endIndex
     * @return
     */
    public boolean isPaindrome(String str, String reverseStr, int startIndex, int endIndex) {
        String substring1 = str.substring(startIndex, endIndex + 1);
        String substring2 = reverseStr.substring(str.length() - endIndex - 1, str.length() - startIndex - 1 + 1);
        return substring1.equals(substring2);
    }
}