一、目錄

• 添加最少字符使字符串整體都是回文字符串
• 回文最少分割數
• 最長回文子串
• 判斷字符串本身是字符串或者刪除一個字符後成為回文串
• 判斷一個字符串在至多刪除k個字符後是否為回文串
• 刪除字符使字符串整體是回文串，最少多少種方案

1、添加最少字符使字符串整體都是回文字符串

思路：動態規劃時間O（N2）

（1）先求出最少需要添加多少個字符串才能補成回文串？

str的長度為N，生成N×N的dp矩陣，dp[i][j]的含義是子串str[i…j]最少添加幾個字符可以使str[i…j]整體都是回文串。dp[i][j]的求法如下：

• 如果i == j，說明此時只有一個字符，本身就是回文串，dp[i][j] = 0。
• 如果str[i…j]有兩個字符，如果這個字符相同dp[i][j] = 0。否則dp[i][j] = 1。
• 如果str[i…j]多於兩個字母，如果str[i] == str[j]。則dp[i][j] = dp[i+1][j-1]。否則，dp[i][j] = min(dp[i+1][j], dp[i][j-1]) + 1。

（2）根據求得的dp矩陣來獲得一種回文結果：【類似最長公共子序列】

dp[0][N-1]的值代表整個字符串最少需要添加幾個字符，所以，如果最後的結果記為字符串res，res的長度為 N + dp[0][N-1]，然後依次設置res左右兩頭的字符。

代碼：

def getPalindrome(str1):
    def getdp(str1):
        dp = [[0 for i in range(len(str1))] for j in range(len(str1))]
        for j in range(1, len(str1)):
            dp[j-1][j] = 0 if str1[j-1] == str1[j] else 1
            for i in range(j-2, -1, -1):
                if str1[i] == str1[j]:
                    dp[i][j] = dp[i+1][j-1]
                else:
                    dp[i][j] = min(dp[i+1][j], dp[i][j-1]) + 1
        return dp


    if str1 == None or len(str1) < 2:
        return str1
    dp = getdp(str1)
    res = [0 for i in range(len(str1)+dp[0][len(str1)-1])]
    i = 0
    j = len(str1) - 1
    resl = 0
    resr = len(res) - 1
    while i <= j:
        if str1[i] == str1[j]:
            res[resl] = str1[i]
            res[resr] = str1[j]
            i += 1
            j -= 1
        elif dp[i+1][j] < dp[i][j-1]:
            res[resl] = str1[i]
            res[resr] = str1[i]
            i += 1
        else:
            res[resl] = str1[j]
            res[resr] = str1[j]
            j -= 1
        resl += 1
        resr -= 1
    return ‘‘.join(res)

進階問題思路：假設str的長度為N，strlps的長度為M，則整體回文串的長度為2×N - M。整個過程類似 “剝洋蔥”。比如：

str = ‘A1BC22D1EF’ , str1 = ‘1221‘，先剝1。A----1BC22D1------EF，1的外殼是left= A,right = EF,則左邊補（right逆序+left），右邊補（left逆序+right）。即FEA----1BC22D1-------AEF。

第二層為2，：FEA1----BC------22-------D----1AEF，left=BC，right= D。同理。

進階問題代碼：

def getPalindrome2(str1, strlps):
    if str1 == None or len(str1) == 0 or strlps == None or len(strlps) == 0:
        return 
    res = [0 for i in range(2*len(str1)-len(strlps))]
    lstr = 0
    rstr = len(str1)-1
    llps = 0
    rlps = len(strlps)-1
    lres = 0
    rres = len(res)-1
    while llps <= rlps:
        temp1 = lstr
        temp2 = rstr
        while str1[lstr] != strlps[llps]:
            lstr += 1
        while str1[rstr] != strlps[rlps]:
            rstr -= 1
        for i in range(temp1, lstr): 
            res[lres] = str1[i]
            res[rres] = str1[i]
            lres += 1
            rres -= 1
        for i in range(temp2, rstr, -1):
            res[lres] = str1[i]
            res[rres] = str1[i]
            lres += 1
            rres -= 1
        res[lres] = str1[lstr]
        res[rres] = str1[rstr]
        lstr += 1
        rstr -= 1
        lres += 1
        rres -= 1
        llps += 1
        rlps -= 1
    return ‘‘.join(res)

2、回文最少分割數【動態規劃】

給定一個字符串str,返回把str全部切成回文子串的最小分割數。

思路：動態規劃時間O（N2），空間O（N2）

定義動態規劃數組dp，dp[i]的含義是子串str[0…i]至少需要切割幾次，才能把str[0…i]全部切成回文子串。那麽dp[len-1]就是最後的結果。

1. 1、假設 j 處在 0 到 i 之間，如果str[j…i]是回文串，那麽dp[i]的值可能是dp[j-1] + 1，其含義是在str[0…i]上，既然str[j…i]是回文串，那麽它可以自己作為一個分割的部分，剩下的部分str[0…j-1]繼續做最經濟的分割，也就是dp[j-1]的值。
2. 根據步驟1的方式，讓 j 在 i 到 0 的位置上枚舉，那麽所有可能中最小值就是dp[i]的值，即dp[i] = min{dp[j-1]+1 (0<= j <= i，且str[j…i]必須是回文串)}。
3. 如何快速方便的判斷str[j…i]是否為回文串？

• • 定義一個二維數組p，如果p[j][i]為True，表示str[j…i]是回文串，否則不是。在計算dp過程中，希望能夠同步、快速的計算出矩陣p。
  • p[j][i]如果為True，一定來自以下三種情況：
    • <1>　str[j][i]由一個字符組成
      <2>　str[j][i]由兩個字符組成且兩個字符相等
      <3>　str[j][i]由多個字符組成，str[j] == str[i]且p[j+1][i-1] == True。
  • 在計算dp數組的過程中，位置i是從左向右依次計算的。而對於每一個i來說，又依次從 i 位置向左遍歷所有的位置，以此來決策dp[i]。所以對於p[j][i]來說，p[j+1][i-1]一定已經計算過。

代碼：

import sys
#從前往後遍歷
def minCut(str1):
    if str1 == None or str1 == "":
        return 0
    N = len(str1)
    p = [[False for i in range(N)] for j in range(N)]
    dp = [0 for i in range(N)]
    for i in range(N):
        dp[i] = sys.maxsize
        for j in range(i, -1, -1):
            if str1[j] == str1[i] and (i-j < 2 or p[j+1][i-1]):
                p[j][i] = True
                dp[i] = min(dp[i], 0 if j-1 == -1 else dp[j-1] + 1)
    return dp[-1]

字符串（1)----回文字符串