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

一、目录

• 添加最少字符使字符串整体都是回文字符串
• 回文最少分割数
• 判断字符串是否是回文串
• 判断字符串本身是字符串或者删除一个字符后成为回文串
• 判断一个字符串在至多删除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]就是最后的结果。

从左往右依次计算dp[i]的值，i 初始为0，具体计算过程如下：

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]

3、题目：判断字符串本身是回文字符

解法1：头尾指针向中间扫描。时间复杂度：O(n)，空间复杂度：O(1)。

同时从字符串头尾开始向中间扫描字串，如果所有字符都一样，那么这个字串就是一个回文。采用这种方法的话，我们只需要维护头部和尾部两个扫描指针即可。

解法2：两个指针分别从中间往两边扫描。时间复杂度：O(n)，空间复杂度：O(1)。

#判断一个字符串是否是回文串
def isPalindrome(str1):
    if len(str1) <= 0:
        return False
    n = len(str1)
    for i in range(n // 2):
        if str1[i] != str1[n - i - 1]:
            return False
    return True

 

4、题目：给定一个非空字符串 s，最多删除一个字符。判断是否能成为回文字符串。

解题思路：

• 使用双指针，一个指向头，一个指向尾，如果两者不相同了，则可以将尾部的往前挪一个，或者首部的往后挪一个，判断这两种情况

• 这两种已经相当于删除了一个字符，如果不是回文字符串，说明删除一个字符满足不了要求

def isPalind(s):
    if not s:
        return False
    n = len(s)
    for i in range(n//2):
        if s[i] != s[n-i-1]:
            return helper(s[i+1:n-i]) or helper(s[i:n-i-1])
    return True
def helper(s):
    if not s:
        return False
    n = len(s)
    for i in range(n//2):
        if s[i] != s[n-i-1]:
            return False
    return True
    
s = 'abbac'
isPalind(s)

 

 

 

转载于:https://www.cnblogs.com/Lee-yl/p/10461472.html