题目描述（困难难度）
和 131 题 一样，可以在任意位置切割字符串，需要保证切割后的每个子串都是回文串。问最少需要切割几次。
和 131 题 用相同的分析方法即可。
解法一 分治
大问题化小问题，利用小问题的结果，解决当前大问题。
举个例子。
aabb
先考虑在第 1 个位置切割，a | abb
这样我们只需要知道 abb 的最小切割次数，然后加 1，记为 m1
aabb
再考虑在第 2 个位置切割，aa | bb
这样我们只需要知道 bb 的所有结果，然后加 1，记为 m2
aabb
再考虑在第 3 个位置切割，aab|b
因为 aab 不是回文串，所有直接跳过
aabb
再考虑在第 4 个位置切割，aabb |
因为 aabb 不是回文串，所有直接跳过
此时只需要比较 m1 和 m2 的大小，选一个较小的即可。
然后中间的过程求 abb 的最小切割次数，求 aab 的最小切割次数等等，就可以递归的去求。递归出口的话，如果字符串的长度为 1,那么它就是回文串了，最小切割次数就是 0 。
此外，和 131 题 一样，我们用一个 dp 把每个子串是否是回文串，提前存起来。
public int minCut(String s) {
boolean[][] dp = new boolean[s.length()][s.length()];
int length = s.length();
for (int len = 1; len <= length; len++) {
for (int i = 0; i <= s.length() - len; i++) {
int j = i + len - 1;
dp[i][j] = s.charAt(i) == s.charAt(j) && (len < 3 || dp[i + 1][j - 1]);
}
}
return minCutHelper(s, 0, dp);
}
private int minCutHelper(String s, int start, boolean[][] dp) {
//长度是 1 ，最小切割次数就是 0
if (dp[start][s.length() - 1]) {
return 0;
}
int min = Integer.MAX_VALUE;
for (int i = start; i < s.length(); i++) {
//只考虑回文串
if (dp[start][i]) {
//和之前的值比较选一个较小的
min = Math.min(min, 1 + minCutHelper(s, i + 1, dp));
}
}
return min;
}
意料之中，超时了。
优化方法的话，memoization 技术，前边很多题都用到了，比如 87 题，91 题 等等。就是为了解决递归过程中重复解的计算，典型例子比如斐波那契数列。用一个 map ，把递归过程中的结果存储起来。
public int minCut(String s) {
boolean[][] dp = new boolean[s.length()][s.length()];
int length = s.length();
HashMap map = new HashMap<>();
for (int len = 1; len <= length; len++) {
for (int i = 0; i <= s.length() - len; i++) {
int j = i + len - 1;
dp[i][j] = s.charAt(i) == s.charAt(j) && (len < 3 || dp[i + 1][j - 1]);
}
}
return minCutHelper(s, 0, dp, map);
}
private int minCutHelper(String s, int start, boolean[][] dp, HashMap map) {
if (map.containsKey(start)) {
return map.get(start);
}
if (dp[start][s.length() - 1]) {
return 0;
}
int min = Integer.MAX_VALUE;
for (int i = start; i < s.length(); i++) {
if (dp[start][i]) {
min = Math.min(min, 1 + minCutHelper(s, i + 1, dp, map));
}
}
map.put(start, min);
return min;
}
接下来还是一样的讨论，既然用到了 memoization 技术，一定就可以把它改写为动态规划，让我们理一下递归的思路。
如上图，图中 a,b,c,d 表示括起来的字符串的最小切割次数。此时需要求问号处括起来的字符串的最小切割次数。
对应于代码中的下边这一部分了。
int min = Integer.MAX_VALUE;
for (int i = start; i < s.length(); i++) {
if (dp[start][i]) {
min = Math.min(min, 1 + minCutHelper(s, i + 1, dp, map));
}
}
如下图，先判断 start 到 i 是否是回文串，如果是的话，就用 1 + d 和之前的 min 比较。
如下图，i 后移，继续判断 start 到 i 是否是回文串，如果是的话，就用 1 + c 和之前的 min 比较。
然后 i 继续后移重复上边的过程。每次选一个较小的切割次数，最后问号处就求出来了。
接着 start 继续前移，重复上边的过程，直到求出 start 等于 0 的最小切割次数就是我们要找的了。
仔细考虑下上边的状态，其实状态转移方程也就出来了。
用 dp[i] 表示字符串 s[i,s.lenght-1]，也就是从 i 开始到末尾的字符串的最小切割次数。
求 dp[i] 的话，假设 s[i,j] 是回文串。
那么 dp[i] = Min(min,dp[j + 1]).
然后考虑所有的 j，其中 j > i ，找出最小的即可。
当然上边的动态规划和递归的方向是一样的，也没什么毛病。不过我们也可以逆过来，从左往右求。
这样的话，用 dp[i] 表示字符串 s[0,i]，也就是从开头到 i 的字符串的最小切割次数。
求 dp[i] 的话，假设 s[j,i] 是回文串。
那么 dp[i] = Min(min,dp[j - 1]).
然后考虑所有的 j，也就是 j = i, j = i - 1, j = i - 2, j = i - 3.... ，其中 j < i ，找出最小的即可。
之前代码用过 dp 变量了，所以用 min 变量表示上边的 dp。
public int minCut(String s) {
boolean[][] dp = new boolean[s.length()][s.length()];
int length = s.length();
for (int len = 1; len <= length; len++) {
for (int i = 0; i <= s.length() - len; i++) {
int j = i + len - 1;
dp[i][j] = s.charAt(i) == s.charAt(j) && (len < 3 || dp[i + 1][j - 1]);
}
}
int[] min = new int[s.length()];
min[0] = 0;
for (int i = 1; i < s.length(); i++) {
int temp = Integer.MAX_VALUE; //找出最小的
for (int j = 0; j <= i; j++) {
if (dp[j][i]) {
//从开头就匹配，不需要切割
if (j == 0) {
temp = 0;
break;
//正常的情况
} else {
temp = Math.min(temp, min[j - 1] + 1);
}
}
}
min[i] = temp;
}
return min[s.length() - 1];
}
当然我们可以优化一下，注意到求 dp 和 求 min 的时候都用到了两个 for 循环，同样都是根据前边的状态更新当前的状态，所以我们可以把他们糅合在一起。
public int minCut(String s) {
boolean[][] dp = new boolean[s.length()][s.length()];
int[] min = new int[s.length()];
min[0] = 0;
for (int i = 1; i < s.length(); i++) {
int temp = Integer.MAX_VALUE;
for (int j = 0; j <= i; j++) {
if (s.charAt(j) == s.charAt(i) && (j + 1 > i - 1 || dp[j + 1][i - 1])) {
dp[j][i] = true;
if (j == 0) {
temp = 0;
} else {
temp = Math.min(temp, min[j - 1] + 1);
}
}
}
min[i] = temp;
}
return min[s.length() - 1];
}
解法二 回溯
回溯法其实就是一个 dfs 的过程。在当前字符串找到第一个回文串的位置，然后切割。剩余的字符串进入递归，继续找回文串的位置，然后切割。直到剩余的字符串本身已经是一个回文串了，就记录已经切过的次数。
可以用一个全局变量，保存已经切过的次数，然后到最后更新。
public int minCut(String s) {
boolean[][] dp = new boolean[s.length()][s.length()];
int length = s.length();
for (int len = 1; len <= length; len++) {
for (int i = 0; i <= s.length() - len; i++) {
int j = i + len - 1;
dp[i][j] = s.charAt(i) == s.charAt(j) && (len < 3 || dp[i + 1][j - 1]);
}
}
minCutHelper(s, 0, dp, 0);
return min;
}
int min = Integer.MAX_VALUE;
//num 记录已经切割的次数
private void minCutHelper(String s, int start, boolean[][] dp, int num) {
if (dp[start][s.length() - 1]) {
min = Math.min(min, num);
return;
}
//尝试当前字符串所有的切割位置
for (int i = start; i < s.length() - 1; i++) {
if (dp[start][i]) {
minCutHelper(s, i + 1, dp, num + 1);
}
}
}
同样出现了超时的问题。
我们可以像解法一一样优化一下，用一个 map 存一下递归过程的中的解。那么问题来了，解法一是把返回值存了起来，但是这个解法并没有返回值，那么我们存什么呢？和 115 题 一样，存增量。什么意思呢？
我们知道 minCutHelper函数是计算了从 start 开始的字符串，全部切割完成后还需要切割的次数，并且当前已经切割了 num 次。也就是执行完下边的 for 循环后，如果全局变量min 更新了，那么多切割的次数就是 min - num，我们把它存起来就可以了。如果 min 没更新，那就不用管了。
for (int i = start; i < s.length() - 1; i++) {
if (dp[start][i]) {
minCutHelper(s, i + 1, dp, num + 1);
}
}
这样只需要在进入递归前，判断之前有没有算过从 start 开始的字符串所带来的增量即可。
public int minCut(String s) {
boolean[][] dp = new boolean[s.length()][s.length()];
int length = s.length();
for (int len = 1; len <= length; len++) {
for (int i = 0; i <= s.length() - len; i++) {
int j = i + len - 1;
dp[i][j] = s.charAt(i) == s.charAt(j) && (len < 3 || dp[i + 1][j - 1]);
}
}
HashMap map = new HashMap<>();
minCutHelper(s, 0, dp, 0, map);
return min;
}
int min = Integer.MAX_VALUE;
private void minCutHelper(String s, int start, boolean[][] dp, int num, HashMap map) {
//直接利用之前存的增量
if (map.containsKey(start)) {
min = Math.min(min, num + map.get(start));
return;
}
if (dp[start][s.length() - 1]) {
min = Math.min(min, num);
return;
}
for (int i = start; i < s.length() - 1; i++) {
if (dp[start][i]) {
minCutHelper(s, i + 1, dp, num + 1, map);
}
}
// min 是否更新了
if (min > num) {
map.put(start, min - num);
}
}
解法三
上边的解法是一些通用的思考方式，针对这道题还有一种解法，在 这里 看到的，也分享一下吧。
同样也是动态规划的思路，用 dp[i] 表示字符串 s[0,i]，也就是从开头到 i 的字符串的最小切割次数。相比于之前更新 dp 的方式，这里的话把之前存储每个子串是否是回文串的空间省去了。
基本思想就是遍历每个字符，以当前字符为中心向两边扩展，判断扩展出来的是否回文串，比如下边的例子。
0 1 2 3 4 5 6
c f d a d f e
^
c
现在以 a 为中心向两边扩展，此时第 2 个和第 4 个字符相等，我们就可以更新
dp[4] = Min(dp[4],dp[1] + 1);
也就是在当前回文串前边切一刀
然后以 a 为中心继续向两边扩展，此时第 1 个和第 5 个字符相等，我们就可以更新
dp[5] = Min(dp[5],dp[0] + 1);
也就是在当前回文串前边切一刀
然后继续扩展，直到当前不再是回文串，把中心往后移动，考虑以 d 为中心，继续更新 dp
当然上边是回文串为奇数的情况，我们还需要考虑以当前字符为中心的偶数的情况，是一样的道理。
可以参考下边的代码。
public int minCut(String s) {
int[] dp = new int[s.length()];
int n = s.length();
//假设没有任何的回文串，初始化 dp
for (int i = 0; i < n; i++) {
dp[i] = i;
}
// 考虑每个中心
for (int i = 0; i < s.length(); i++) {
// j 表示某一个方向扩展的个数
int j = 0;
// 考虑奇数的情况
while (true) {
if (i - j < 0 || i + j > n - 1) {
break;
}
if (s.charAt(i - j) == s.charAt(i + j)) {
if (i - j == 0) {
dp[i + j] = 0;
} else {
dp[i + j] = Math.min(dp[i + j], dp[i - j - 1] + 1);
}
} else {
break;
}
j++;
}
// j 表示某一个方向扩展的个数
j = 1;
// 考虑偶数的情况
while (true) {
if (i - j + 1 < 0 || i + j > n - 1) {
break;
}
if (s.charAt(i - j + 1) == s.charAt(i + j)) {
if (i - j + 1 == 0) {
dp[i + j] = 0;
} else {
dp[i + j] = Math.min(dp[i + j], dp[i - j + 1 - 1] + 1);
}
} else {
break;
}
j++;
}
}
return dp[n - 1];
}
总
前边的解法还是很常规，从递归到动态规划，利用分治或者回溯，以及 memoization 技术，经常用到了。最后一个解法，边找回文串边更新 dp ，从而降低了空间复杂度，也是很妙了。
更多详细通俗题解详见 leetcode.wang 。