Python實現常見的回文字串演算法

2021-10-01 08:43:02 字數 4112 閱讀 3211

利用python 自帶的翻轉 函式reversed()

def is_plalindrome(string):    


return string == ''.join(list(reversed(string)))
自己實現

def is_plalindrome(string):


string = list(string)


length = len(string)


left = 0


right = length - 1


while left < right:


if string[left] != string[right]:


return false


left += 1


right -= 1


return true
當然還有切片string[::-1]
暴力破解，列舉所有的子串，對每個子串判斷是否為回文， 時間複雜度為 o(n^3)

def solution(s):


s = list(s)


l = len(s)


dp = [[0] * l for i in range(l)]


for i in range(l):


dp[i][i] = true


# 當 k = 2時要用到


dp[i][i - 1] = true


resleft = 0


resright = 0


# 列舉子串的長度


for k in range(2, l+1):


# 子串的起始位置


for i in range(0, l-k+1):


j = i + k - 1


if s[i] == s[j] and dp[i + 1][j - 1]:


dp[i][j] = true


# 儲存最長的回文起點和終點


if resright - resleft + 1 < k:


resleft = i


resright = j


return ''.join(s[resleft:resright+1])
時間複雜度為 o(n^2), 空間複雜度為 o(n^2)

manacher 演算法首先對字串做乙個預處理,使得所有的串都是奇數長度, 插入的是同樣的符號且符號不存在與原串中，串的回文性不受影響

aba => #a#b#a#


abab => #a#b#a#b#
我們把回文串中最右位置與其對稱軸的距離稱為回文半徑，manacher 演算法定義了乙個回文半徑陣列 rl，rl[i]表示以第 i 個字元為對稱軸的回文半徑，對於上面得到的插入分隔符的串來說，我們可以得到 rl陣列

char:  # a # b # a #


rl:    1 2 1 4 1 2 1


rl-1:  0 1 0 3 0 1 0


i:     0 1 2 3 4 5 6


char: # a # b # a # b #


rl:   1 2 1 4 1 4 1 2 1


rl-1: 0 1 0 3 0 3 0 1 0


i:    0 1 2 3 4 5 6 7 8
我們還求了 rl[i] - 1: 我們發現rl[i] -1 正好是初始字串中以位置i 為對稱軸的最長回文長度

下面是演算法實現

def manacher(pres):


s = '#' + '#'.join(pres) + '#'


l = len(s)


rl = [0] * l


maxright = pos = maxlen = 0


for i in range(l):


if i < maxright:


rl[i] = min(rl[2*pos - i], maxright-i)


else:


rl[i] = 1


while i - rl[i] >= 0 and i + rl[i] < l and s[i - rl[i]] == s[i + rl[i]]:


rl[i] += 1


if i + rl[i] - 1 > maxright:


maxright = i + rl[i] - 1


pos = i


maxlen = max(rl)


idx = rl.index(maxlen)


sub = s[idx - maxlen + 1: idx + maxlen]


return sub.replace('#', '')
空間複雜度：借助了乙個輔助陣列，空間複雜度為 o(n) 時間複雜度：儘管內層存在迴圈，但是內層迴圈只對尚未匹配的部分進行，對於每乙個字元來說，只會進行一次，所以時間複雜度是 o(n)

所謂字首，就是以第乙個字元開始

下面的最長回文字首

abbabbc => abbc


abababb => ababa


sogou => s
將原串逆轉，那麼問題就轉變為求原串的字首和逆串字尾相等且長度最大的值, 這個問題其實就是 kmp 演算法中的 next 陣列的求解了

具體求解： 將原串逆轉並拼接到原串中， 以』#』 分隔原串和逆轉避免內部字串干擾。

def longest_palindrome_prefix(s):


if not s:


return 0


s = s + '#' + s[::-1] + '$'


i = 0


j = -1


nt = [0] * len(s)


nt[0] = -1


while i < len(s) - 1:


if j == -1 or s[i] == s[j]:


i += 1


j += 1


nt[i] = j


else:


j = nt[j]


return nt[len(s) - 1]
這道題其實跟上面基本是一樣的， 例項：

aacecaaa -> aaacecaaa # 新增 a


abcd -> dcbabcd # 新增 dcb
我們先求字串的最長回文字首, 然後剩餘的字串逆轉並拼接到字串的頭部即是問題所求

def solution(s):


length = longest_palindrome_prefix(s)


return s[length:][::-1] + s
dp[i][j] 表示子串行 s[i..j] 中存在的最長回文子串行長度

初始化dp[i][i] = 1

當 s[i] == s[j] 為 true 時，dp[i][j] = dp[i+1][j - 1] + 2

當 s[i] == s[j] 為 false 時，dp[i][j] = max(dp[i+1][j], dp[i][j - 1])

# 求得最長回文子串行的長度


def solution(s):


l = len(s)


dp = [[0] * l for i in range(l)]


for i in range(l):


dp[i][i] = 1


# 列舉子串的長度


for k in range(2, l+1):


# 列舉子串的起始位置


for i in range(0, l-k+1):


j = i + k - 1


if s[i] == s[j]:


dp[i][j] = dp[i + 1][j - 1] + 2


else:


dp[i][j] = max(dp[i][j - 1], dp[i + 1][j])


return dp[0][l-1]
時間複雜度為 o(n^2), 空間複雜度為 o(n^2)

**：

python 回文字串

題目內容 給定乙個字串，判斷它是否是回文字串 即類似於peep,12321這樣的對稱字串 如果是輸出true，不是則輸出false。判斷過程中假定只考慮字母和數字字元，而且忽略字母的大小寫和其它符號 如空格 標點符號等 輸入格式 共一行，為乙個字串。輸出格式 共一行，為true或false。輸入樣例...

python實現 判斷回文字串 回文鍊錶 回文數

所謂回文字串，就是正讀和反讀都一樣的字串，比如 level 或者 noon 等等就是回文串。即是對稱結構 判斷回文字串 方法一 def is palindrome s return true if s s 1 else false方法二 def is palindrome s length len ...

python 回文字串 回文數字

所謂回文字串，就是乙個字串，從左到右讀和從右到左讀是完全一樣的。回文數字也是如此。python2 如下 def huiwen s s1 str s if s1 join reversed s1 return true else return false 執行結果 huiwen abccba true...