题目链接：https://leetcode-cn.com/problems/longest-chunked-palindrome-decomposition/

题目要求

段式回文 其实与 一般回文 类似，只不过是最小的单位是 一段字符 而不是 单个字母。

举个例子，对于一般回文 "abcba" 是回文，而 "volvo" 不是，但如果我们把 "volvo" 分为 "vo"、"l"、"vo" 三段，则可以认为 “(vo)(l)(vo)” 是段式回文（分为 3 段）。

给你一个字符串 text，在确保它满足段式回文的前提下，请你返回 段 的 最大数量 k。
如果段的最大数量为 k，那么存在满足以下条件的 a_1, a_2, ..., a_k：每个 a_i 都是一个非空字符串；将这些字符串首位相连的结果 a_1 + a_2 + ... + a_k 和原始字符串 text 相同；
对于所有1 <= i <= k，都有 a_i = a_{k+1 - i}。

示例 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)"。

示例 4：
输入：text = "aaa"
输出：3
解释：我们可以把字符串拆分成 "(a)(a)(a)"。

算法实现

一、双向指针算法

** 核心思想：**将右侧指针左移找到第一个与左侧指针当前位置元素相同的字符，然后判断右侧指针滑过的字符串与左测指针滑过相同长度的字符串是否一致，如果一致则最大段数max_len加2，如果不一致继续左移重复前面的判断，直到达到边界条件：左侧指针等于或大于右侧指针位置，如果相等则会有一个单独的字符串存在，如果左侧指针大于右侧指针说明已经结束了
python3代码实现：

def longestDecomposition(text: str) -> int:
    l_index: int = 0   
    r_index: int = len(text) - 1
    last_pos: int = len(text)
    count: int = 0
    while l_index < r_index :
        if text[l_index] != text[r_index] :
            r_index = r_index - 1
            continue
        else:
            if text[r_index : last_pos] == text[l_index : l_index + (last_pos - r_index)]:
                count += 2
                l_index = l_index + (last_pos - r_index)
                last_pos = r_index
                r_index =r_index - 1
            else:
                r_index = r_index - 1
    if l_index == r_index:
        count += 1
    return count

if __name__ == '__main__':
        print(longestDecomposition("ghiabcdefhelloadamhelloabcdefghi"))

二、hash算法

核心思想：分别定义左侧指针和右侧指针，每次向中间移动一个字符，然后计算移动过字符串的hash值，对比左侧字符串的hash值与右侧字符串的hash值是否一致，如果一致则总数加2，临界状态：左侧hash与右侧hash不一致，并且左侧索引大于右侧索引时，说明有一个独立的字符串，总数加1，如果左侧索引等于右侧索引值时也说明有一个独立的字符串，总数加1

python3代码实现

def longestDecomposition(text:str):
    hash1:int = 0
    hash2:int = 0
    l_index: int =0
    r_index: int = len(text)-1
    f: int = 31
    k: int =1
    cnt: int = 0
    while l_index < r_index:
        hash1 = f * hash1 + ord(text[l_index])
        hash2 = hash2 + k * ord(text[r_index])
        k *= f
        if hash1 == hash2:
            cnt += 2
            hash1 = 0
            hash2 = 0
            k = 1
        l_index += 1
        r_index -= 1
    if hash1 != hash2:
        cnt +=1
    if l_index == r_index:
        cnt += 1

    return cnt

if __name__ == '__main__':
    print(longestDecomposition("ghiabcdefhelloadamhelloabcdefghi"))

更多实现可跳转至leetcode查看