牛客NC17 最长回文子串(动态规划)

原题链接

中心扩散法

    /**
     *  中心扩散法
     *
     * @param A
     * @param n
     * @return
     */
    public int getLongestPalindrome(String A, int n) {
        // write code here
        char[] chars = A.toCharArray();
        if (chars.length == 0) return 0;
        int maxLen = 1;

        for (int i = 0; i < n - 1; i++){
            // 以chars[i]为中心寻找回文串，以chars[i]和chars[i + 1]为中心寻找回文串
            maxLen = Math.max(maxLen, Math.max(findPalindrome(chars, i, i), findPalindrome(chars, i, i + 1)));
        }

        return maxLen;
    }

    /**
     * 以 chars[l] 和 chars[r] 为中心寻找回文串，
     * chars[l] 可以等于 chars[r]
     *
     * @param chars
     * @param l
     * @param r
     * @param i
     * @return      返回最长回文串的长度
     */
    public int findPalindrome(char[] chars, int l, int r){
        int k = 0;

        while (!(l - k < 0 || r + k > chars.length - 1 || chars[l - k] != chars[r + k]))
                k++;

        r += k - 1;
        l -= k - 1;
        return r - l + 1;
    }

动态规划

    /**
     *  动态规划
     *      状态 boolean dp[i][j], A[i]到A[j]是不是一个回文字符串
     *          当 i = j 时， dp[i][j] = true
     *
     *      状态转移方程：
     *          当 A[i] = A[j]时，dp[i][j] = dp[i + 1][j - 1]
     *          否则，dp[i][j] = false
     *      关键就在于要先得到 dp[i + 1][j - 1]，才能得到dp[i][j]
     * @param A
     * @param n
     * @return
     */
    public int getLongestPalindrome(String A, int n) {
        // write code here
        if (n == 0) return 0;
        char[] chars = A.toCharArray();
        boolean[][] dp = new boolean[n][n];
        int maxLen = 1;

        // 字符串首尾字母的距离
        for (int len = 0; len < n; len++){
            // i是字符串的开始位置
            for (int i = 0; i < n - len; i++){
                // 单个字母一定是回文串
                if(len == 0)
                    dp[i][i + len] = true;
                // 两个相邻且相等的字母也能构成回文串
                else if(len == 1)
                    dp[i][i + len] = (chars[i] == chars[i + len]);
                else {
                    dp[i][i + len] = (chars[i] == chars[i + len] && dp[i + 1][i + len - 1]);
                }
                if(dp[i][i + len])
                    maxLen = Math.max(len + 1, maxLen);
            }
        }

        return maxLen;
    }