分别利用动态规划和镜像法解决回文字符串

问题描述

给出一个字符串s，找出一个具有最长长度的回文字符串

例子

input : “abad”
output : “aba”

解决方法1 : 动态规划

时间复杂度O(n^2)
空间复杂度O(n^2)
记m[i][j]记录从下标i到下标j的子串是否回文字符串，若是则为真，反之则为假。
记chars为题目给出的字符串s的数组表示。
递归式：m[i][j] = (chars[i] == chars[j] and m[i + 1][j - 1])
由上面的递归式可得，只有chars[i] == chars[j]和m[i + 1][j - 1]同时为真，m[i][j]才为真。
先要解决两个最基本的子问题：
1.m[i][i]，这个肯定为真
2.m[i][i+1]，只有chars[i] == chars[i + 1]才为真
现在就可以自底向上解决所有子问题，最后解决原问题，代码如下

public String longestPalindrome(String s) {
        char[] chars = s.toCharArray();
        int length = chars.length;
        //若m[i][j]为真，表示从下标i到下标j的子串是回文字符串，反之则不是回文字符串
        boolean[][] m = new boolean[length][length];
        //初始化矩阵m
        //两种情况:
        //1.m[i][i] = true
        //2.若相邻元素相等，则m[i][i+1]=true，否则为false
        for (int i = 0; i < length; i++) {
            for (int j = 0; j < length; j++) {
                if (i == j) {
                    m[i][j] = true;
                } else if (i == j - 1 && chars[i] == chars[j]) {
                    m[i][j] = true;
                }
            }
        }

        //由于初始化已经解决了m[i][i]和m[i][i+1]两种情况
        //接下来自底向上解决所有m[i][j] (j - i >= 2)
        for (int l = 3; l <= length; l++) {
            int j;
            for (int i = 0; i < length && i + l - 1  < length; i++) {
                j = l + i - 1;
                m[i][j] = chars[i] == chars[j] && m[i + 1][j - 1];
            }
        }
        //根据矩阵m重构最优解
        int left = 0, right = 0;
        for (int i = 0; i < length; i++) {
            for (int j = length - 1; j >=i ; j--) {
                if (m[i][j] && j - i > right - left) {
                    left = i;
                    right = j;
                    break;
                }

            }
        }
        return new String(chars, left, right - left + 1);
    }

解决方法2 : 镜像法

时间复杂度O(n^2)
空间复杂度O(1)
原理：从左到右遍历每个元素，然后以该元素为中心，从左右两侧分别扩展，若左元素等于右元素相等，则再判断左左元素和右右元素是否相等，以此类推。

public String longestPalindrome(String s) {
        int length = s.length();
        //数组指针，从0到length-1遍历
        int p = 0;
        //分别代表中间元素的左元素和右元素下标
        int i, j;
        //暂存长度
        int tmp;
        //记录最大回文长度对应的左下标和右下标
        int maxLeft = 0, maxRight = 0;
        //从左到右遍历
        while (p < length - 1) {
            tmp = 1;
            i = p - 1;
            //判断右元素是否和本元素相等，若相同则一直循环直到不等
            while (p < length - 1 && s.charAt(p) == s.charAt(p + 1)) {
                tmp += 1;
                p++;
            }
            j = p + 1;
            //从左边和右边同时扩展
            while (i >= 0 && j < length && s.charAt(i) == s.charAt(j)) {
                tmp += 2;
                i--;
                j++;
            }
            //若长度大于最大值，则更新最大值以及左下标和有下标
            if (tmp > maxRight - maxLeft + 1) {
                maxLeft = ++i;
                maxRight = --j;
            }
            p++;
        }
        return s.substring(maxLeft, maxRight + 1);
    }