跳转至

2472. 不重叠回文子字符串的最大数目

来源第 319 场周赛 Q4难度困难分数2013

题目描述

给你一个字符串 s 和一个 正 整数 k 。

从字符串 s 中选出一组满足下述条件且 不重叠 的子字符串：

  • 每个子字符串的长度 至少 为 k 。
  • 每个子字符串是一个 回文串 。

返回最优方案中能选择的子字符串的 最大 数目。

子字符串 是字符串中一个连续的字符序列。

 

示例 1 ：

输入：s = "abaccdbbd", k = 3
输出：2
解释：可以选择 s = "abaccdbbd" 中斜体加粗的子字符串。"aba" 和 "dbbd" 都是回文，且长度至少为 k = 3 。
可以证明，无法选出两个以上的有效子字符串。

示例 2 ：

输入：s = "adbcda", k = 2
输出：0
解释：字符串中不存在长度至少为 2 的回文子字符串。

 

提示：

  • 1 <= k <= s.length <= 2000
  • s 仅由小写英文字母组成

解法

方法一：预处理 + 动态规划

思考

要选出尽量多条长度至少为 \(k\) 且互不重叠的回文子串。\(n \le 2000\)，按切分方案搜索状态过多。子串是否回文可以先用区间 DP 在 \(O(n^2)\) 内全部算好，记在 \(g[i][j]\)。剩下只是在这些合法区间里做不重叠选取：从位置 \(i\) 出发，要么丢掉 \(s[i]\)，要么选一条以 \(i\) 开头、长度至少为 \(k\) 的回文再跳到它的右端点之后。从右往左填 \(f[i]\)，每个位置的决策只依赖更大的下标。

我们先预处理字符串 \(s\)，得到 \(g[i][j]\) 表示子串 \(s[i..j]\) 是否为回文串。

然后定义 \(f[i]\) 表示从字符串 \(s[i..]\) 中能选出的不重叠回文子串的最大个数。初始时 \(f[n] = 0\)。对于 \(i\) 从 \(n - 1\) 倒序遍历到 \(0\)，可以选择跳过 \(s[i]\)，即 \(f[i] = f[i + 1]\)；也可以枚举结束位置 \(j\)（\(j \ge i + k - 1\)），若 \(g[i][j]\) 为真，则可以选中该回文串，并从 \(j + 1\) 继续。即：

\[ \begin{aligned} f[i] &= \begin{cases} 0, & i \geq n \\ \max\bigl\{f[i + 1],\ \max\limits_{\substack{j \ge i + k - 1 \\ g[i][j]}} \{f[j + 1] + 1\}\bigr\}, & i < n \end{cases} \end{aligned} \]

时间复杂度 \(O(n^2)\)，空间复杂度 \(O(n^2)\)。其中 \(n\) 为字符串 \(s\) 的长度。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
class Solution:
    def maxPalindromes(self, s: str, k: int) -> int:
        n = len(s)
        g = [[True] * n for _ in range(n)]
        for i in range(n - 1, -1, -1):
            for j in range(i + 1, n):
                g[i][j] = s[i] == s[j] and g[i + 1][j - 1]
        f = [0] * (n + 1)
        for i in range(n - 1, -1, -1):
            f[i] = f[i + 1]
            for j in range(i + k - 1, n):
                if g[i][j]:
                    f[i] = max(f[i], 1 + f[j + 1])
        return f[0]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class Solution {
    public int maxPalindromes(String s, int k) {
        int n = s.length();
        boolean[][] g = new boolean[n][n];
        for (var row : g) {
            Arrays.fill(row, true);
        }
        for (int i = n - 1; i >= 0; --i) {
            for (int j = i + 1; j < n; ++j) {
                g[i][j] = s.charAt(i) == s.charAt(j) && g[i + 1][j - 1];
            }
        }
        int[] f = new int[n + 1];
        for (int i = n - 1; i >= 0; --i) {
            f[i] = f[i + 1];
            for (int j = i + k - 1; j < n; ++j) {
                if (g[i][j]) {
                    f[i] = Math.max(f[i], 1 + f[j + 1]);
                }
            }
        }
        return f[0];
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class Solution {
public:
    int maxPalindromes(string s, int k) {
        int n = s.size();
        bool g[n][n];
        memset(g, true, sizeof(g));
        for (int i = n - 1; ~i; --i) {
            for (int j = i + 1; j < n; ++j) {
                g[i][j] = s[i] == s[j] && g[i + 1][j - 1];
            }
        }
        int f[n + 1];
        memset(f, 0, sizeof(f));
        for (int i = n - 1; ~i; --i) {
            f[i] = f[i + 1];
            for (int j = i + k - 1; j < n; ++j) {
                if (g[i][j]) {
                    f[i] = max(f[i], 1 + f[j + 1]);
                }
            }
        }
        return f[0];
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
func maxPalindromes(s string, k int) int {
    n := len(s)
    g := make([][]bool, n)
    for i := range g {
        g[i] = make([]bool, n)
        for j := range g[i] {
            g[i][j] = true
        }
    }
    for i := n - 1; i >= 0; i-- {
        for j := i + 1; j < n; j++ {
            g[i][j] = s[i] == s[j] && g[i+1][j-1]
        }
    }
    f := make([]int, n+1)
    for i := n - 1; i >= 0; i-- {
        f[i] = f[i+1]
        for j := i + k - 1; j < n; j++ {
            if g[i][j] {
                f[i] = max(f[i], 1+f[j+1])
            }
        }
    }
    return f[0]
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
function maxPalindromes(s: string, k: number): number {
    const n = s.length;
    const g: boolean[][] = Array.from({ length: n }, () => Array(n).fill(true));
    for (let i = n - 1; ~i; --i) {
        for (let j = i + 1; j < n; ++j) {
            g[i][j] = s[i] === s[j] && g[i + 1][j - 1];
        }
    }
    const f: number[] = Array(n + 1).fill(0);
    for (let i = n - 1; ~i; --i) {
        f[i] = f[i + 1];
        for (let j = i + k - 1; j < n; ++j) {
            if (g[i][j]) {
                f[i] = Math.max(f[i], 1 + f[j + 1]);
            }
        }
    }
    return f[0];
}

评论