LeetCode每日一题（20200819）

原题地址

思考过程

如果使用暴力求解，遍历所有子串，判断是否满足，时间复杂度会比较大，O(n³)，性能不行
找到可以去重的可能性，如果某字符串不是回文，那在他左右各加n个字符后的新串，也一定不是回文
看了下题目相关标签，动态规划，如果使用DP，那么该怎么分解问题呢

暴力求解：

遍历所有子串，然后依次判断是否是回文

代码实现：

public int countSubstrings(String s) {
        int ans = 0;
        for (int i = 0; i < s.length(); i++) {
            for (int j = i + 2; j <= s.length(); j++) {
                if (isPalindromic(s, i, j)) {
                    ans++;
                }
            }
        }
        return ans + s.length();

    }

    private boolean isPalindromic(String s, int begin, int end) {
        while (end - begin > 1) {
            if (s.charAt(begin) != s.charAt(end - 1)) {
                return false;
            } else {
                begin++;
                end--;
            }
        }

        return true;
    }

执行结果：

执行用时：633 ms
内存消耗：38 MB

 

算法复杂度分析：

时间复杂度：O(n³)，其中 n是字符串长度。

空间复杂度：O(n)，其中 n 是字符串长度。

 

查看官方解法：

解法一：中心拓展，是我上文思考（如果某字符串不是回文，那在他左右各加n个字符后的新串，也一定不是回文）的延续。为什么我在有了这个思考后，没能继续下一步，然后实现出高效代码？我觉得是是在思路到代码实现这一块能力不足，需要多加训练，而且在找到一个可能正确的思路后，没能证明该思路的正确性。

解题过程：先找到回文字符串可能的中间点，这里分为两种情况，奇回文和偶回文，奇回文的中间点是一个字符，而偶回文的中间点是在两个字符之间。

看完官方解法一的思路后，实现了以下代码：

 //中心扩散法
    public int countSubstrings2(String s) {
        int ans = 0;
        //奇回文
        for (int i = 0; i < s.length(); i++) {
            int left = i, right = i;
            while (left >= 0 && right < s.length() ) {
                if (s.charAt(left) == s.charAt(right)) {
                    ans++;
                    left--;
                    right++;
                } else {
                    break;
                }

            }
        }
        //偶回文
        for (int i = 0; i < s.length(); i++) {
            int left = i, right = i + 1;
            while (left >= 0 && right < s.length() ) {
                if (s.charAt(left) == s.charAt(right)) {
                    ans++;
                    left--;
                    right++;
                } else {
                    break;
                }

            }
        }
        return ans;
    }

执行结果：

性能大幅提升。

官方代码：（简洁，膜拜。。。）

public int countSubstrings(String s) {
        int n = s.length(), ans = 0;
        for (int i = 0; i < 2 * n - 1; ++i) {
            int l = i / 2, r = i / 2 + i % 2;
            while (l >= 0 && r < n && s.charAt(l) == s.charAt(r)) {
                --l;
                ++r;
                ++ans;
            }
        }
        return ans;
    }

 

解法二：Manacher 算法（马拉车算法）。和中心拓展法类似，然后在他的基础上，用更巧妙的方法处理奇偶回文。

看完马拉车算法后实现代码如下：

 public int countSubstrings3(String s) {

        //字符串处理  "abc" ->  "^a#b#c$"
        char dec = '#';
        char head = '^';
        char tail = '$';
        StringBuilder sb = new StringBuilder();
        sb.append(head).append(dec);
        for (int i = 0; i < s.length(); i++) {
            if (i == s.length() - 1) {
                sb.append(s.charAt(i)).append(dec).append(tail);
            } else {
                sb.append(s.charAt(i)).append(dec);
            }
        }
        String newS = sb.toString();

        int[] arr = new int[newS.length() - 2];
        for (int i = 1; i < newS.length() - 1; i++) {
            int left = i;
            int right = i;
            int v = 0;
            while (newS.charAt(left) != head && newS.charAt(right) != tail
                    && newS.charAt(left) == newS.charAt(right)) {
                v++;
                left--;
                right++;
            }
            arr[i - 1] = v;
        }
        int ans = 0;
        for (int i : arr) {
            ans += (i / 2);
        }
        return ans;
    }

执行结果：

执行用时：12 ms
内存消耗：37.9 MB

性能并没有得到提升，对比了官方马拉车代码，发现我的代码拉的车不对，我还没有理解马拉车的精要，这里还需要花点时间多加理解。

 

官方马拉车代码：

 public int countSubstrings4(String s) {
        int n = s.length();
        StringBuffer t = new StringBuffer("$#");
        for (int i = 0; i < n; ++i) {
            t.append(s.charAt(i));
            t.append('#');
        }
        n = t.length();
        t.append('!');

        int[] f = new int[n];
        int iMax = 0, rMax = 0, ans = 0;
        for (int i = 1; i < n; ++i) {
            // 初始化 f[i]
            f[i] = i <= rMax ? Math.min(rMax - i + 1, f[2 * iMax - i]) : 1;
            // 中心拓展
            while (t.charAt(i + f[i]) == t.charAt(i - f[i])) {
                ++f[i];
            }
            // 动态维护 iMax 和 rMax
            if (i + f[i] - 1 > rMax) {
                iMax = i;
                rMax = i + f[i] - 1;
            }
            // 统计答案, 当前贡献为 (f[i] - 1) / 2 上取整
            ans += f[i] / 2;
        }

        return ans;
    }

执行结果：

执行用时：3 ms, 在所有 Java 提交中击败了91.69%的用户
 内存消耗：37.7 MB, 在所有 Java 提交中击败了80.50%的用户