例题一
解法(动态规划):
算法思路:
我们可以先「预处理」⼀下,将所有⼦串「是否回⽂」的信息统计在dp 表⾥⾯,然后直接在表⾥⾯统计 true
的个数即可。
1.
状态表⽰:
为了能表⽰出来所有的⼦串,我们可以创建⼀个
n * n
的⼆维
dp 表,只⽤到「上三⻆部分」即可。其中, dp[i][j]
表⽰:
s
字符串
[i, j]
的⼦串,是否是回⽂串。
2.
状态转移⽅程:
对于回⽂串,我们⼀般分析⼀个「区间两头」的元素:
i.
当 s[i] != s[j] 的时候:不可能是回⽂串, dp[i][j] = false
;
ii.
当 s[i] == s[j] 的时候:根据⻓度分三种情况讨论:
•
⻓度为 1 ,也就是 i == j :此时⼀定是回⽂串,
dp[i][j] = true
;
•
⻓度为 2 ,也就是 i + 1 == j :此时也⼀定是回⽂串,
dp[i][j] = true
;
•
⻓度⼤于 2 ,此时要去看看
[i + 1, j - 1]
区间的⼦串是否回⽂:
dp[i][j] = dp[i + 1][j - 1] 。综上,状态转移⽅程分情况谈论即可。
3.
初始化:
因为我们的状态转移⽅程分析的很细致,因此⽆需初始化。
4.
填表顺序:
根据「状态转移⽅程」,我们需要「从下往上」填写每⼀⾏,每⼀⾏的顺序⽆所谓。
5.
返回值:
根据「状态表⽰和题⽬要求」,我们需要返回
dp
表中
true
的个数。
例题二
解法(动态规划):
算法思路:
a.
我们可以先⽤ dp
表统计出「所有⼦串是否回⽂」的信息
b.
然后根据 dp
表⽰
true
的位置,得到回⽂串的「起始位置」和「⻓度」。那么我们就可以在表中找出最⻓回⽂串。
例题三
解法(动态规划):
算法思路:
题⽬要求⼀个字符串被分成「三个⾮空回⽂⼦串」,乍⼀看,要表⽰的状态很多,有些⽆从下⼿。
其实,我们可以把它拆成「两个⼩问题」:
i.
动态规划求解字符串中的⼀段⾮空⼦串是否是回⽂串;
ii.
枚举三个⼦串除字符串端点外的起⽌点,查询这三段⾮空⼦串是否是回⽂串。那么这道困难题就免秒变为简单题啦,变成了⼀道枚举题。
例题四
解法(动态规划):
算法思路:
1.
状态表⽰:
根据「经验」,继续尝试⽤
i
位置为结尾,定义状态表⽰,看看能否解决问题:
dp[i]
表⽰:
s
中
[0, i]
区间上的字符串,最少分割的次数。
2.
状态转移⽅程:
状态转移⽅程⼀般都是根据「最后⼀个位置」的信息来分析:设
0 <= j <= i
,那么我们可以根据 j ~ i 位置上的⼦串是否是回⽂串分成下⾯两类:
i.
当 [j ,i]
位置上的⼦串能够构成⼀个回⽂串,那么
dp[i]
就等于
[0, j - 1]
区间上最少回⽂串的个数 + 1,即 dp[i] = dp[j - 1] + 1
;
ii.
当
[j ,i]
位置上的⼦串不能构成⼀个回⽂串,此时
j
位置就不⽤考虑。由于我们要的是最⼩值,因此应该循环遍历⼀遍 j
的取值,拿到⾥⾯的最⼩值即可。
优化:我们在状态转移⽅程⾥⾯分析到,要能够快速判读字符串⾥⾯的⼦串是否回⽂。因此,我们
可以先处理⼀个
dp
表,⾥⾯保存所有⼦串是否回⽂的信息。
3.
初始化:
观察「状态转移⽅程」,我们会⽤到
j - 1
位置的值。我们可以思考⼀下当
j == 0
的时候,表⽰的区间就是 [0, i]
。如果
[0, i]
区间上的字符串已经是回⽂串了,最⼩的回⽂串就是 1 了,
j
往后的值就不⽤遍历了。因此,我们可以在循环遍历 j
的值之前处理
j == 0
的情况,然后
j
从
1
开始循环。但是,为了防⽌求 min
操作时,
0
⼲扰结果。我们先把表⾥⾯的值初始化为「⽆穷⼤」。
4.
填表顺序:
毫⽆疑问是「从左往右」。
5.
返回值:
根据「状态表⽰」,应该返回
dp[n - 1]
。
例题五
解法(动态规划):
算法思路:
1.
状态表⽰:
关于「单个字符串」问题中的「回⽂⼦序列」,或者「回⽂⼦串」,我们的状态表⽰研究的对象⼀
般都是选取原字符串中的⼀段区域
[i, j]
内部的情况。这⾥我们继续选取字符串中的⼀段区域来研究: dp[i][j] 表⽰:s 字符串
[i, j]
区间内的所有的⼦序列中,最⻓的回⽂⼦序列的⻓度。
2.
状态转移⽅程:
关于「回⽂⼦序列」和「回⽂⼦串」的分析⽅式,⼀般都是⽐较固定的,都是选择这段区域的「左
右端点」的字符情况来分析。因为如果⼀个序列是回⽂串的话,「去掉⾸尾两个元素之后依旧是回
⽂串」,「⾸尾加上两个相同的元素之后也依旧是回⽂串」。因为,根据「⾸尾元素」的不同,可
以分为下⾯两种情况:
i.
当⾸尾两个元素「相同」的时候,也就是
s[i] == s[j]
:那么
[i, j]
区间上的最⻓回⽂⼦序列,应该是 [i + 1, j - 1]
区间内的那个最⻓回⽂⼦序列⾸尾填上s[i] 和
s[j]
,此时
dp[i][j] = dp[i + 1][j - 1] + 2
ii.
当⾸尾两个元素不「相同」的时候,也就是
s[i] != s[j]
:此时这两个元素就不能同时添加在⼀个回⽂串的左右,那么我们就应该让 s[i]
单独加在⼀个序列的左边,或者让s[j] 单独放在⼀个序列的右边,看看这两种情况下的最⼤值:
•
单独加⼊ s[i] 后的区间在 [i, j - 1] ,此时最⻓的回⽂序列的⻓度就是 dp[i] [j - 1] ;
•
单独加⼊ s[j] 后的区间在 [i + 1, j] ,此时最⻓的回⽂序列的⻓度就是 dp[i + 1][j] ;
取两者的最⼤值,于是
dp[i][j] = max(dp[i][j - 1], dp[i + 1][j]) 综上所述,状态转移⽅程为:
▪
当 s[i] == s[j] 时:dp[i][j] = dp[i + 1][j - 1] + 2
▪
当 s[i] != s[j] 时:dp[i][j] = max(dp[i][j - 1], dp[i + 1][j])
3.
初始化:
我们的初始化⼀般就是为了处理在状态转移的过程中,遇到的⼀些边界情况,因为我们需要根据状
态转移⽅程来分析哪些位置需要初始化。根据状态转移⽅程 dp[i][j] = dp[i + 1][j - 1] + 2
,我们状态表⽰的时候,选取的是⼀段区间,因此需要要求左端点的值要⼩于等于右端点的值,因此会有两种边界情况:
i.
当 i == j
的时候,
i + 1
就会⼤于
j - 1
,此时区间内只有⼀个字符。这个⽐较好分析, dp[i][j]
表⽰⼀个字符的最⻓回⽂序列,⼀个字符能够⾃⼰组成回⽂串,因此此时dp[i][j] = 1 ;
ii.
当 i + 1 == j 的时候,
i + 1 也会⼤于 j - 1
,此时区间内有两个字符。这样也好分析,当这两个字符相同的时候,dp[i][j] = 2 ;不相同的时候,
d[i][j] = 0 。 对于第⼀种边界情况,我们在填表的时候,就可以同步处理。对于第⼆种边界情况, dp[i + 1][j - 1]
的值为
0
,不会影响最终的结果,因此可以不⽤考虑。
4.
填表顺序:
根据「状态转移」,我们发现,在
dp
表所表⽰的矩阵中,
dp[i + 1]
表⽰下⼀⾏的位置,dp[j - 1] 表⽰前⼀列的位置。因此我们的填表顺序应该是「从下往上填写每⼀⾏」,「每⼀⾏从左往右」。这个与我们⼀般的填写顺序不太⼀致。
5.
返回值:
根据「状态表⽰」,我们需要返回 [0, n -1]
区域上的最⻓回⽂序列的⻓度,因此需要返回dp[0][n - 1] 。
例题六
解法(动态规划):
算法思路:
1.
状态表⽰:
关于「单个字符串」问题中的「回⽂⼦序列」,或者「回⽂⼦串」,我们的状态表⽰研究的对象⼀般都是选取原字符串中的⼀段区域 [i, j]
内部的情况。这⾥我们继续选取字符串中的⼀段区域来研究:状态表⽰: dp[i][j]
表⽰字符串
[i, j]
区域成为回⽂⼦串的最少插⼊次数。
2.
状态转移⽅程:
关于「回⽂⼦序列」和「回⽂⼦串」的分析⽅式,⼀般都是⽐较固定的,都是选择这段区域的「左
右端点」的字符情况来分析。因为如果⼀个序列是回⽂串的话,「去掉⾸尾两个元素之后依旧是回
⽂串」,「⾸尾加上两个相同的元素之后也依旧是回⽂串」。因为,根据「⾸尾元素」的不同,可
以分为下⾯两种情况:
i.
当⾸尾两个元素「相同」的时候,也就是 s[i] == s[j]
:
1.
那么 [i, j]
区间内成为回⽂⼦串的最少插⼊次数,取决于
[i + 1, j - 1]
区间内成为回⽂⼦串的最少插⼊次数;
2.
若 i == j
或
i == j - 1
(
[i + 1, j - 1]
不构成合法区间),此时只有 1 ~ 2 个相同的字符, [i, j]
区间⼀定是回⽂⼦串,成为回⽂⼦串的最少插⼊次数是0。此时dp[i][j] = i >= j - 1 ? 0:dp[i + 1][j-1]
;
ii.
当⾸尾两个元素「不相同」的时候,也就是 s[i] != s[j]
:
1.
此时可以在区间最右边补上⼀个 s[i] ,需要的最少插⼊次数是 [i + 1, j]
成为回⽂⼦串的最少插⼊次数 + 本次插⼊,即 dp[i][j] = dp[i + 1][j] + 1 ;
2.
此时可以在区间最左边补上⼀个 s[j] ,需要的最少插⼊次数是 [i, j + 1]
成为回⽂⼦串的最少插⼊次数 + 本次插⼊,即 dp[i][j] = dp[i][j + 1] + 1 ;
综上所述,状态转移⽅程为:
▪
当 s[i] == s[j] 时: dp[i][j] = i >= j - 1 ? 1 : dp[i + 1][j - 1] 。
▪
当 s[i] != s[j] 时: dp[i][j] = min(dp[i + 1][j], dp[i][j - 1]) + 1 。
3.
初始化:
根据「状态转移⽅程」,没有不能递推表⽰的值。⽆需初始化。
4.
填表顺序:
根据「状态转移」,我们发现,在
dp
表所表⽰的矩阵中,
dp[i + 1]
表⽰下⼀⾏的位置,dp[j - 1] 表⽰前⼀列的位置。因此我们的填表顺序应该是「从下往上填写每⼀⾏」,「每⼀⾏从左往右」。这个与我们⼀般的填写顺序不太⼀致。
5.
返回值:
根据「状态表⽰」,我们需要返回
[0, n -1]
区域上成为回⽂⼦串的最少插⼊次数,因此需要
返回
dp[0][n - 1]
。