中心拓展法——5、647

Utgnryk

已于 2024-07-29 18:36:45 修改

阅读量1k

点赞数 26

分类专栏： LeetCode 文章标签： java

于 2024-07-29 18:34:34 首次发布

本文链接：https://blog.csdn.net/Utgnryk/article/details/140775877

版权

LeetCode 专栏收录该内容

39 篇文章 0 订阅

订阅专栏

5. 最长回文子串（中等）

给你一个字符串 s，找到 s 中最长的

回文子串。

示例 1：
输入：s = "babad"
输出："bab"
解释："aba" 同样是符合题意的答案。
示例 2：
输入：s = "cbbd"
输出："bb"
提示：

1 <= s.length <= 1000
s 仅由数字和英文字母组成

解法一、马拉车

我理解你想让我写中心延展，但我们先拉一下

马拉车具体原理看7.28号的博文。套用过来后的难点在于后面的奇偶讨论，根据经验得知，原串与新串的映射为原（i） = 新（2i + 1），半径映射为原直径=新半径-1。记得分奇偶讨论return时切割串。

private static String preProcess(String s){
        StringBuffer sb = new StringBuffer();
        int n = s.length();
        sb.append("#");
        for(int i = 0;i < n;i++){
            sb.append(s.charAt(i)).append("#");
        }
        return sb.toString();
    }
    public static String longestPalindrome(String s) {
        int R = -1;
        int C = -1;
        String newS = preProcess(s);
        int len = newS.length();
        int[] rArr = new int[len];
        int maxR = Integer.MIN_VALUE;
        int index = -1;
        for(int i = 0;i < len;i++){
            rArr[i] = R>i?Math.min(R-i,rArr[2 * C - i]):1;
            while(i + rArr[i] < len && i - rArr[i] >= 0){
                if(newS.charAt(i+rArr[i]) == newS.charAt(i-rArr[i])){
                    rArr[i]++;
                }else{
                    break;
                }
            }
            if(i + rArr[i] > R){
                R = i+rArr[i];
                C = i;
            }
            if(maxR < rArr[i]){
                maxR = rArr[i];
                index = i;
            }
        }
        int newIndex = (index - 1)/2;
        int newR = maxR - 1;
       return newR % 2 == 0 ? s.substring(newIndex - (newR - 1)/2,newIndex + newR/2 + 1):s.substring(newIndex - (newR - 1)/2,newIndex + (newR+1)/2);
    }

解法二、中心扩散法

其实就是抓住一个字符为中心，讨论它的回文串长度。分奇偶就好

class Solution {
    public String longestPalindrome(String s) {
        if (s == null || s.length() < 1) {
            return "";
        }
        int start = 0, end = 0;
        for (int i = 0; i < s.length(); i++) {
            int len1 = expandAroundCenter(s, i, i);
            int len2 = expandAroundCenter(s, i, i + 1);
            int len = Math.max(len1, len2);
            if (len > end - start) {
                start = i - (len - 1) / 2;
                end = i + len / 2;
            }
        }
        return s.substring(start, end + 1);
    }

    public int expandAroundCenter(String s, int left, int right) {
        while (left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)) {
            --left;
            ++right;
        }
        return right - left - 1;
    }
}

作者：力扣官方题解
链接：https://leetcode.cn/problems/longest-palindromic-substring/solutions/255195/zui-chang-hui-wen-zi-chuan-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

解法三、动态规划

好像理解了···就是先写状态转移方程

dp[i][j]表达i-j是回文串。dp[i][j]是回文串当且仅当dp[i+1][j-1]是回文串且s[i]==s[j]

就是因为转移里是i+1/j-1,所以遍历时候才是i-- j++ 把递归里用的条件先用到一遍

public String longestPalindrome(String s) {
    int len=s.length();
    int left=0,right=0,max=0;
    boolean[][] dp=new boolean[len][len];
    for(int i=len-1;i>=0;i--){
        for(int j=i;j<len;j++){//j=i
            if(s.charAt(i)==s.charAt(j) && (j - i <= 1 || dp[i + 1][j - 1])){//如果j - i <= 1，则是回文串
                dp[i][j] = true;
                if(j-i>max){
                    max=j-i;
                    left=i;
                    right=j;
                }
            }
        }
    }
    return s.substring(left,right+1);
}

647. 回文子串（中等）

给你一个字符串 s ，请你统计并返回这个字符串中 回文子串 的数目。

回文字符串 是正着读和倒过来读一样的字符串。

子字符串 是字符串中的由连续字符组成的一个序列。

示例 1：
输入：s = "abc"
输出：3
解释：三个回文子串: "a", "b", "c"
示例 2：
输入：s = "aaa"
输出：6
解释：6个回文子串: "a", "a", "a", "aa", "aa", "aaa"
提示：

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

解法一、动态规划

对动态规划的数组来说本身就是一个true等于一个ans

class Solution {
    public int countSubstrings(String s) {
        int len = s.length();
        int ans = 0;
        boolean [][] dp = new boolean[len][len];
        for(int i = len - 1;i >=0;i--){
            for(int j = i;j < len;j++){
                if(s.charAt(i) == s.charAt(j) && (j - i <= 2 || dp[i+1][j-1])){
                    dp[i][j] = true;
                    ans++;
                }
            }
        }
        return ans;
    }
}

解法二、中心扩散

这个就懒得写了，对同一个中心，奇的话ans就是它的回文半径数，偶的话也是，但得减另半个中心。讨论偶数与否倒是挺累的

解法三、马拉车

本质上其实就是马拉车处理捏把r数组搞出来。需要特别处理的是，这里也需要考虑到#的情况（第一次直接略过了。。）例如对于aaa,新数组是#a#a#a#，arr内容是1,2,3,4,3,2,1。如果剔除#，处理变成aaa对应直径[1,3,1]，和aba的情况相似，但显然前者答案是6、后者是4。所以需要分奇偶讨论。奇代表处理的其实是#的部分，如果#不是1，代表#两侧字母相等。这里再作一个减一除二操作，也就是把aaa中的aa(0,1)和aa(1,2)纳入讨论。

ans++也完全可以放进主循环搞。这里为了明确就放最后再遍历一次了。这个办法比官方题解的马拉车改进简单很多。。官方那个没看，感觉太复杂了

class Solution {
    private static String preProcess(String s){
        int len = s.length();
        StringBuffer sb = new StringBuffer();
        sb.append("#");
        for(int i = 0;i<len;i++){
            sb.append(s.charAt(i)).append("#");
        }
        return sb.toString();
    }
    public static int countSubstrings(String s) {
        String newS = preProcess(s);
        int ans = 0;
        int C = -1,R = -1,len = newS.length();
        int[] arr = new int[len];
        for(int i = 0;i < len;i++){
            arr[i] = i < R ? Math.min(R - i,arr[2 * C - i]):1;
            while(i + arr[i] < len && i - arr[i] >=0 ){
                if(newS.charAt(i + arr[i]) == newS.charAt(i - arr[i])){
                    arr[i]++;
                }else{
                    break;
                }
            }
            if(i + arr[i] > R){
                R = i+arr[i];
                C = i;
            }
        }
        for(int i = 0;i < len;i++){
            if(i % 2 == 1){//偶数位置
                int r = (arr[i] - 1);//直径
                ans += r % 2 == 1 ? (r+1)/2  : r/2;
            }else{
                ans += (arr[i] - 1)/2;
            }
        }
        return ans;
    }
}