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

演算法 Python · 發表 2018-11-13 23:31:27

摘要：這是崔斯特的第七十篇原創文章迴文利用python 自帶的翻轉函式 reversed() def is_plalindrome(string):return string == ''.join(list(reversed(string)...

這是崔斯特的第七十篇原創文章

迴文

利用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

最長的迴文子串

暴力破解

暴力破解，列舉所有的子串，對每個子串判斷是否為迴文，時間複雜度為 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 演算法

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 為對稱軸的最長迴文長度

所以下面就是重點如何求得 RL 陣列了，可以參考這篇 ofollow,noindex">文章 (講得比較清晰)

下面是演算法實現

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]