LeetCode常见的回文串问题汇总

回文串问题

125. 验证回文串 — 简单题

leetocode链接

给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。

**说明：**本题中，我们将空字符串定义为有效的回文串。

示例 1:

输入: "A man, a plan, a canal: Panama"
输出: true
解释："amanaplanacanalpanama" 是回文串

示例 2:

输入: "race a car"
输出: false
解释："raceacar" 不是回文串

提示：

• 1 <= s.length <= 2 * 105
• 字符串 s 由 ASCII 字符组成

代码实现 — 使用双指针法

class Solution {
    public boolean isPalindrome(String s) {
        StringBuffer sb = new StringBuffer();
        int length = s.length();
        for (int i = 0; i < length; i++) {
            char ch = s.charAt(i);
            //使用Character的isLetterOrDigit()来判断其是否为数字或者字母
            if (Character.isLetterOrDigit(ch)) {
                sb.append(Character.toLowerCase(ch));
            }
        }
        int n = sb.length();
        int left = 0, right = n - 1;
        while (left < right) {
            if (sb.charAt(left) != sb.charAt(right)) {
                return false;
            }
            ++left;
            --right;
        }
        return true;
    }
}

5. 最长回文子串 — 中等题

leetcode链接

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

示例 1：

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

示例 2：

输入：s = "cbbd"
输出："bb"

示例 3：

输入：s = "a"
输出："a"

示例 4：

输入：s = "ac"
输出："a"

提示：

• 1 <= s.length <= 1000
• s 仅由数字和英文字母（大写和/或小写）组成

思路分析：

这道题可以采用动态规划和左右扩散法进行求解：

其中动态规划法，我们可以定义一个二维的boolean数组dp[n] [n]，其中dp[i] [j]表示表示[i,…,j]区间的子串是否为回文串，此时我们初始化：

• 只有一个字母一定为回文串，两个字母如果相等，也一定为回文串

  for (int i = 0; i < n; i++) {
      dp[i][i] = true;
  }
  for (int i = 1; i < n; i++) {
      if (s.charAt(i) == s.charAt(i - 1)) {
          dp[i - 1][i] = true;
      }
  }
  

• 动态转移方程：如果如果【i + 1, j - 1】区间是回文串，并且此时i和j位置的值相等，则说明【i,j】为回文串
  $$\begin{gathered} if(dp[i+1][j-1]并且s.charAt(i)==s.charAt(j)) \\ dp[i][j]=true; \end{gathered}$$

然后我们定义一个最长回文子串的起始索引，以及其最长的长度，更新最后得到我们的结果集

而如果采取左右扩散法，就是以每一个字母作为中心点，向左右扩散，以满足回文串的要求

代码实现：

class Solution {
    public String longestPalindrome(String s) {
        int n = s.length();
        if(n == 1) return s;
        //表示[i,....,j]区间的子串是否为回文串
        boolean[][] dp = new boolean[n][n];
        String ans = "";
        int begin = 0;
        int maxLen = 1;
        //初始化:只有一个字母一定为回文串，两个字母如果相等，也一定为回文串
        for (int i = 0; i < n; i++) {
            dp[i][i] = true;
        }
        for (int i = 1; i < n; i++) {
            if (s.charAt(i) == s.charAt(i - 1)) {
                dp[i - 1][i] = true;
                begin = i - 1;
                maxLen = 2;
            }
        }
        //更新结果集：更新的区间的长度从2开始
        for (int j = 2; j < n; j++) { //j ∈ [2 ---> n - 1]
            for (int i = j - 2; i >= 0; i--) { //i ∈ [j - 1 ---> 0]
                //如果【i + 1, j - 1】区间是回文串，并且此时i和j位置的值相等，则说明【i,j】为回文串
                if (dp[i + 1][j - 1] && s.charAt(i) == s.charAt(j)) {
                    dp[i][j] = true;
                }
                if (dp[i][j] && (j - i + 1) > maxLen) {
                    begin = i;
                    maxLen = j - i + 1;
                }
            }
        }
        return s.substring(begin,begin + maxLen);
    }
}

class Solution {
    public String longestPalindrome(String s) {
        //使用左右扩展法
        int n = s.length();
        int window = 0;
        String ans = "";
        for(int i = 0; i < n; i++) {  //从0 ~ n,正常遍历
            //左扩展
            int left = i - 1;
            while(left >= 0 && s.charAt(left) == s.charAt(i)) {
                --left;
            }
            //右扩散
            int right = i + 1;
            while(right <= n - 1 && s.charAt(right) == s.charAt(i)) {
                ++right;
            }
            //左右扩散,此时left和right指向不满足的情况
            while(left >= 0 && right <= n -1 && s.charAt(left) == s.charAt(right)) {
                --left;
                ++right;  
            }
			//判断以及更新结果集
            if(right - left - 1 > window) {
                window = right - left - 1;
                ans = s.substring(left + 1,right);
            }
        }
        return ans;
    }      
}

516. 最长回文子序列 — 中等题

leetcode链接

给你一个字符串 s ，找出其中最长的回文子序列，并返回该序列的长度。

子序列定义为：不改变剩余字符顺序的情况下，删除某些字符或者不删除任何字符形成的一个序列。

示例 1：

输入：s = "bbbab"
输出：4
解释：一个可能的最长回文子序列为 "bbbb" 。

示例 2：

输入：s = "cbbd"
输出：2
解释：一个可能的最长回文子序列为 "bb" 。

提示：

• 1 <= s.length <= 1000
• s 仅由小写英文字母组成

class Solution {
    public int longestPalindromeSubseq(String s) {
        //使用动规划进行求解
        int n = s.length();
        //dp[i][j]表示区间【i,j】的最长回文子序列的长度
        int[][] dp = new int[n][n];
        int res = 1;
        //初始化,只有一个字母的话，一定为回文串
        for (int i = 0; i < n; i++) {
            dp[i][i] = 1;
        }
        //动态更新
        for (int j = 1; j < n; j++) { //列
            char c1 = s.charAt(j);
            for(int i = j - 1; i >= 0; i--) { //行
                char c2 = s.charAt(i);
                if(c1 == c2) {
                    //如果c1和c2相等，则dp[i][j] = dp[i + 1][j - 1] + 2
                    dp[i][j] = dp[i + 1][j - 1] + 2;
                }else {
                    //如果不相等，则直接为dp[i + 1][j]和dp[i][j - 1]的最大值
                    dp[i][j] = Math.max(dp[i + 1][j],dp[i][j - 1]);
                }
            }
        }
        return dp[0][n - 1];
    }
}

131. 分割回文串 — 中等题

leetcode链接

给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是 回文串 。返回 s 所有可能的分割方案。

回文串 是正着读和反着读都一样的字符串。

示例 1：

输入：s = "aab"
输出：[["a","a","b"],["aa","b"]]

示例 2：

输入：s = "a"
输出：[["a"]]

提示：

• 1 <= s.length <= 16
• s 仅由小写英文字母组成

思路分析：

采用 回溯法 + 判断回文串来求解该问题

代码实现：

class Solution {
    List<List<String>> ans = new ArrayList<>();
    List<String> sub = new ArrayList<>();
    int n;
    StringBuilder sb;
    public List<List<String>> partition(String s) {
        sb = new StringBuilder(s);
        n = s.length();
        dfs(0);
        return ans;
    }

    private void dfs(int start) {
        if(start == n) { 
            //如果此时start移动到n的位置,说明s字符串全部分解为若干个回文子串,我们选择将sub加入结果集中
            ans.add(new ArrayList<>(sub));
            return;
        }

        for (int i = start; i < n; i++) {
            //首先判断sb字符串[start,i]位置是否为回文串,如果是,则继续递归判断
            if (judge(sb.substring(start,i + 1))) {
                sub.add(sb.substring(start,i + 1));
                dfs(i + 1);
                //回溯
                sub.remove(sub.size() - 1);
            }
        }
    }

    //判断是否为回文串的方法
    private boolean judge(String s) {
        int left = 0;
        int right = s.length() - 1;
        while (left < right) {
            if (s.charAt(left) != s.charAt(right)) {
                return false;
            }
            ++left;
            --right;
        }
        return true;
    }
}

132. 分割回文串 II — 困难题

leetcode链接

给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是回文。

返回符合要求的 最少分割次数 。

示例 1：

输入：s = "aab"
输出：1
解释：只需一次分割就可将 s 分割成 ["aa","b"] 这样两个回文子串。

示例 2：

输入：s = "a"
输出：0

示例 3：

输入：s = "ab"
输出：1

提示：

• 1 <= s.length <= 2000
• s 仅由小写英文字母组成

思路分析：

使用动态规划进行求解，我们可以利用最长回文子串中的dp(数组dp[i] [j]表示【i，j】区间是否为回文串)，然后建立一个新的dp数组f[n]：

其中f[i]表示字符串到索引i位置分割成回文串的最少次数，首先我们初始化f[i] = i（初始化为最大值）

然后我们动态更新f数组的值：j ∈ 【1，n - 1】

如果dp[0][j]为true: f[j] = 0
否则，我们遍历i ∈ [0 , j - 1] : 
如果dp[i + 1][j]为true : f[i] = Math.min(f[j],f[i] + 1]

class Solution {
    public int minCut(String s) {
        int n = s.length();
        //定义第一个dp数组
        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] = dp[i + 1][j - 1] && (s.charAt(i) == s.charAt(j));
            }
        }
        //定义第二个dp数组
        int[] f = new int[n];
        //初始化
        for(int i = 0; i < n; i++) {
            f[i] = i;
        }
        for(int j = 1; j < n; j++) {
            //如果【0，j】区间是回文的，直接赋值为0，无需切割
            if(dp[0][j]) {
                f[j] = 0;
            }else {
                for(int i = 0; i < j; i++) {
                    if(dp[i + 1][j]) {
                        f[j] = Math.min(f[j],f[i] + 1);
                    }
                }
            }
        }
        return f[n - 1];
    }
}