LeetCode 刷题记之段式回文

题目

题目描述

你会得到一个字符串 $text$ 。你应该把它分成 $k$ 个子字符串 $(subtex{t}_1,subtex{t}_2，\cdots ，subtex{t}_k$) ，要求满足:

• $subtex{t}_i$ 是 非空 字符串
• 所有子字符串的连接等于 $text$ (即 $subtex{t}_1+subtex{t}_2+\cdots +subtex{t}_k=text$)
• 对于所有 $i$ 的有效值( 即 $1\le i\le k$ ) ，$subtex{t}_i=subtex{t}_{k-i+1}$ 均成立

返回 $k$ 可能最大值。

示例

示例 1

输入：$text="ghiabcdefhelloadamhelloabcdefghi"$

输出：$7$

解释：我们可以把字符串拆分成 $"(ghi)(abcdef)(hello)(adam)(hello)(abcdef)(ghi)"$。

示例 2

输入：$text="merchant"$

输出：$1$

解释：我们可以把字符串拆分成 $"(merchant)"$。

示例 3

输入：$text="antaprezatepzapreanta"$

输出：$11$

解释：我们可以把字符串拆分成 $"(a)(nt)(a)(pre)(za)(tpe)(za)(pre)(a)(nt)(a)"$。

提示

$1\le text.length\le 1000$

$text$ 仅由小写英文字符组成

思路

我的思路

1: 定义两个指针 $i\leftarrow 0,j\leftarrow text.length-1$

2: 令 $k\leftarrow 0$

3: 当 $i<=j$ 时

3-1: 令 $t\leftarrow j$

3-2: 当 $text[i]\ne text[j]$ 时

3-2-1: 若 $j<\lceil \frac{i+t}{2}\rceil$，则 $k\leftarrow k+1$ 并跳转到步骤 4

3-2-2: 否则 $j\leftarrow j-1$

3-2-3: 若 $i=j$，则 $k\leftarrow k+1$ 并跳转到步骤 4

3-3: 若 $text[i:i+(t-j+1)]=text[j:t+1]$ 则，$i\leftarrow i+(t-j+1),j\leftarrow text.length-1-i$、$k\leftarrow k+2$

3-4: 否则 $j\leftarrow j-1$ 并跳转到步骤 3-2

4: 返回 $k$

改进思路

由于指针 $j$ 在回退寻找与指针 $i$ 所指向字符中已经遍历了一次，后续判断字串是否相等时又重复遍历了一次，因此极大增加了算法时间

以下是改进算法

1: 令 $k=0$

2: 定义两个空列表 $a,b$

3: 定义指针 $i=0$

4: 当 $i<\lfloor \frac{text.length}{2}\rfloor$ 时

4-1: 将 $text$ 的第 $i$ 个字符加入列表 $a$，倒数第 $i+1$ 个字符加入列表 $b$

4-2: 若列表 $a$ 等于列表 $b$ 的逆序，则 $k\leftarrow k+2$ 并清空列表 $a,b$

5: 若 $text.length\mathrm{mod}2=0$，则 $k\leftarrow k+1$

6: 若 $a$ 或 $b$ 列表不为空，则 $k\leftarrow k+1$

7: 返回 $k$

代码实现

我的思路实现

class Solution:
    def longestDecomposition(self, text: str) -> int:
        lengh_text = len(text)
        i, j = 0, lengh_text - 1
        k, t = 0, j
        while i <= j:
            while text[i] != text[j]:
                if j < (i+t) // 2 + 1:
                    return k + 1
                else:
                    j -= 1
            if i == j:
                return k + 1
            if text[i:i+(t-j+1)] == text[j:t+1]:
                k += 2
                i += t - j + 1
                j = lengh_text - 1 - i
            else:
                j -= 1
                continue
            t = j
        return k

改进思路实现

class Solution:
    def longestDecomposition(self, text: str) -> int:
        k = 0
        a, b = [], []
        length = len(text)
        for i in range(length // 2):
            a.append(text[i]), b.append(text[-(i+1)])
            if a == b[::-1]:
                k += 2
                a.clear(), b.clear()
        if length % 2 != 0 or len(a) != 0:
            k += 1
        return k