Leetcode5. 最长回文子串

原创已于 2022-07-04 23:36:29 修改 · 202 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode

于 2020-03-07 21:06:46 首次发布

Leetcode 专栏收录该内容

214 篇文章

订阅专栏

本文详细解析了LeetCode上经典题目——最长回文子串的求解方法，通过动态规划的方式，利用二维数组记录子串是否为回文，从而找出给定字符串中最长的回文子串。

Leetcode5. 最长回文子串

题目：
给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。
示例 1：

输入: "babad"
输出: "bab"
注意: "aba" 也是一个有效答案。

示例 2：

输入: "cbbd"
输出: "bb"

题解：
定义一个二维数组，对于字符串中的subString()是左闭右开区间

	c	a	b	a
c	T	T	F	F	F
a	T	T	T	F	T
b		T	T	T	F
a			T	T	T

主对角线上的表示空字符，一定是回文串；
主对角线上方的对角，表示单个字符，一定是回文串；
其他的数据，比如arr[1][5]=T,表示字符串从a开始，到最后结束，为“aba”是回文串，给T。
scala代码：

 /**
    *
    * @param s
    * @return
    */
  def longestPalindrome2(s: String): String = {
    if (s == null || s.length == 0) {
      null
    } else {
      var maxStr = ""
      val n = s.length
      //数组左闭右开i == j || i + 1 == j表示空字符或者单个字符肯定是回文串
      val bool = Array.ofDim[Boolean](n + 1, n + 1)
      for (j <- 0 until n + 1) {
        for (i <- j to 0 by -1) {
          if (i == j || i + 1 == j) {
            bool(i)(j) = true
          } else if (s.charAt(i) == s.charAt(j - 1) && bool(i + 1)(j - 1)) {
            bool(i)(j) = true
          }
          if (i != j && bool(i)(j) && maxStr.length < j - i) {
            maxStr = s.substring(i, j)
          }

        }
      }
      maxStr
    }
  }

java代码

  public static String longestPalindrome(String s) {
        int len = s.length();
        if (len < 2) return s;

        int maxLen = 1;
        int begin = 0;

        boolean[][] b = new boolean[len][len];
        for (int i = 0; i < len; i++) {
            b[i][i] = true;
        }

        //枚举子串的长度
        for (int L = 2; L <= len; L++) {
            // 枚举左边界，左边界的上限设置可以宽松一些
            for (int i = 0; i < len; i++) {
                // 由 L 和 i 可以确定右边界，即 j - i + 1 = L 得
                int j = L + i - 1;
                if (j >= len) break;

                if (s.charAt(i) != s.charAt(j)) {
                    b[i][j] = false;
                } else {
                    if (j - i < 3) {
                        b[i][j] = true;
                    } else {
                        b[i][j] = b[i + 1][j - 1];
                    }
                }

                if (b[i][j] && j - i + 1>maxLen) {
                    maxLen = j - i + 1;
                    begin = i;
                }
            }
        }
        return s.substring(begin, begin + maxLen);
    }