关于回文的简单练习

前言

对于字符串来说，处理回文来说是非常常见的事，其实回文也类似连续数组，可以采用滑动窗口解决。除此之外，还有专门解决回文的经典算法。

案例

1、最多删除一个字符得到回文

2、回文子字符串的个数

二、题解

1、最多删除一个字符得到回文

package com.xhu.offer.offerII;

//有效的回文
public class IsPalindrome {
    public boolean isPalindrome(String s) {
        //双指针判断就行
        int len = s.length(), begin = 0, end = len - 1;

        s = s.toLowerCase();

        while (begin < end) {
            char ch1 = s.charAt(begin), ch2 = s.charAt(end);

            boolean flag1 = ch1 <= 57 && ch1 >= 48 || ch1 <= 122 && ch1 >= 97;
            boolean flag2 = ch2 <= 57 && ch2 >= 48 || ch2 <= 122 && ch2 >= 97;

            if (!(flag1 && flag2)) {
                begin += flag1 ? 0 : 1;
                end += flag2 ? 0 : -1;

                continue;
            }
            if (ch1 != ch2) return false;

            begin++;
            end--;
        }
        return true;
    }

    //最多删除一个字符得到回文
    public boolean validPalindrome(String s) {
        //数组拆解，局部与整体
        int len = s.length(), begin = 0, end = len - 1;

        while (begin < end) {
            char ch1 = s.charAt(begin), ch2 = s.charAt(end);

            if (ch1 == ch2) {
                begin++;
                end--;

                continue;
            }
            return isRight(s, begin + 1, end) || isRight(s, begin, end - 1);
        }
        return true;
    }

    private boolean isRight(String s, int low, int high) {
        for (; low < high; low++, high--) if (s.charAt(low) != s.charAt(high)) return false;

        return true;
    }

}

2、回文子字符串的个数

package com.xhu.offer.offerII;

//回文字符串的个数
public class CountSubstrings {
    public int countSubstrings(String s) {
        //动态规划 + 数组拆解思想
        //总结：拆解问题里的数据结构可能就是在拆解问题，也可能就是动态规划的基础。
        int len = s.length();

        int[] dp = new int[len];

        int res = 0;
        for (int i = 0; i < len; i++) {
            for (int j = 0; j <= i; j++) {
                if (s.charAt(i) != s.charAt(j)) {
                    dp[j] = 0;

                    continue;
                }
                boolean flag = i == j || i - 1 == j || dp[j + 1] == 1;

                dp[j] = flag ? 1 : 0;
                res += flag ? 1 : 0;
            }
        }
        return res;
    }

    //优化，中心扩展
    public int countSubstrings2(String s) {
        //中心扩展
        int res = 0, len = s.length();

        for (int i = 0; i < len; i++) {
            //只能左扩
            res += count(s, i + 1, i - 1)
                    + count(s, i, i - 1) + 1;
        }
        return res;
    }

    private int count(String s, int begin, int end) {
        int res = 0, len = s.length();

        while (begin < len && end >= 0) {
            if (s.charAt(begin++) != s.charAt(end--)) break;

            res++;
        }
        return res;
    }
    //优化，manacher算法
    public int countSubstrings3(String s) {
        //总结：利用已有或已创造的条件，可以降低时空复杂度。
        //除了算法逻辑，代码的细节也可以降低运行时间，让代码执行得更快，比如说下面的前后加一个不等的字符，就不需要每次判断是否越界了。
        //除此之外，与其写在循环内一个if+break，不如写在循环的条件上。
        int res = 0, len = s.length();

        StringBuilder sb = new StringBuilder();
        //首尾多加一个不相等字符，后面就不用每次判断是否要越界，不等就不循环了，即不等就break了
        sb.append("&#");

        for (int i = 0; i < len; i++) {
            sb.append(s.charAt(i));
            sb.append("#");
        }
        sb.append("!");

        int length = sb.length() - 2;
        int iM = 0, rM = 0;
        int[] f = new int[length];

        for (int i = 1; i < length; i++) {
            //在最长回文的保证下，快速计算其初始臂的最小值
            f[i] = i <= iM ? Math.min(f[2 * iM - i], rM - i + 1) : 1;
            //一直往右扩展。
            while (sb.charAt(i + f[i]) == sb.charAt(i - f[i])) f[i]++;

            //更新iM,rM
            if (i + f[i] - 1 > rM) {
                iM = i;
                rM = i + f[i] - 1;
            }
            res += f[i] / 2;
        }
        return res;
    }
}

总结

1）拆解问题里的数据结构可能就是在拆解问题，也可能就是动态规划的基础。
2）利用已有或已创造的条件，可以降低时空复杂度。
3）除了算法逻辑，代码的细节也可以降低运行时间，让代码执行得更快，
a）比如说下面的前后加一个不等的字符，就不需要每次判断是否越界了。
b）除此之外，与其写在循环内一个if+break，不如写在循环的条件上。

参考文献

[1] LeetCode 最多删除一个字符得到回文
[2] LeetCode 回文子字符串的个数