本来以为java回暖了，结果4k还嫌多。。

精品推荐：

《征服数据结构》专栏：50多种数据结构彻底征服。

《经典图论算法》专栏：50多种经典图论算法全部掌握。

一网友发文称，Java回暖了，大半夜收到几个offer，该网友要求薪资4k左右，结果hr还嫌多，其他网友评论说：这么搞还不如去养猪算了。

4k还嫌多，估计最多也就3千多，也可能是2千多，也可能是……，算了，如果是2千多还不如去养猪了。一天收到上百份java简历，就因为人多，各种压榨，压榨到令人发指的程度。

网友评论：

--------------下面是今天的算法题--------------

来看下今天的算法题，这题是LeetCode的第132：分割回文串 II。

问题描述

来源：LeetCode第132题

难度：困难

给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是回文串。返回符合要求的最少分割次数 。

示例1：

输入：s = "aab"

输出：1

解释：只需一次分割就可将 s 分割成 ["aa","b"] 这样两个回文子串。

示例2：

输入：s = "a"

输出：0

• 1 <= s.length <= 2000

• s 仅由小写英文字母组成

问题分析

昨天讲过《分割回文串》，昨天那道题让返回的是所有可能的分割方案，而这题让求的是最小分割次数。

这题可以使用动态规划来解决，定义dp[i]表示前 i 个字符的最小分割次数。

1，如果前 i 个字符构成的子串s[0,i]是回文串，则不需要分割，也就是dp[i]=0。

2，否则就尝试分割，从前 i 个字符中不断截取子串s[j,i]，判断子串s[j,i]是否是回文串，如果是回文串，表示子串s[j,i]可以单独分割，然后前面分割的最少次数就是dp[j-1]，所以dp[i]=min(dp[i],dp[j-1]+1);

这里还是和昨天一样，需要先对所有的子串进行预处理，提前知道哪些是回文的，哪些不是。

JAVA：

public int minCut(String s) {
    int length = s.length();
    int[] dp = new int[length];
    // 判断子串[i…j]是否是回文串
    boolean[][] palindrome = new boolean[length][length];
    for (int j = 0; j < length; j++) {
        for (int i = 0; i <= j; i++) {
            // 如果子串s[j,i]是回文串，则两边的字符s[i]和s[j]必须相同，并且
            // 中间的子串s[i+1,j-1]如果存在，也必须是回文串。
            if (s.charAt(i) == s.charAt(j) && (j - i <= 2 || palindrome[i + 1][j - 1]))
                palindrome[i][j] = true;
        }
    }

    // 字符串s的回文子串最大也只能是字符串的长度，这里都默认初始化为最大值。
    Arrays.fill(dp, length);
    for (int i = 0; i < length; i++) {
        // 如果子串s[0,i]本身就是回文的，就不需要分隔。
        if (palindrome[0][i]) {
            dp[i] = 0;
        } else {
            // 否则就要分隔，找出最小的分隔方案
            for (int j = 0; j <= i; ++j) {
                if (palindrome[j][i])
                    dp[i] = Math.min(dp[i], dp[j - 1] + 1);
            }
        }
    }
    return dp[length - 1];
}

C++：

public:
    int minCut(string s) {
        int length = s.length();
        // 判断子串[i…j]是否是回文串
        vector<vector<bool>> palindrome(length, vector<bool>(length, false));
        for (int j = 0; j < length; j++) {
            for (int i = 0; i <= j; i++) {
                // 如果子串s[j,i]是回文串，则两边的字符s[i]和s[j]必须相同，并且
                // 中间的子串s[i+1,j-1]如果存在，也必须是回文串。
                if (s[i] == s[j] && (j - i <= 2 || palindrome[i + 1][j - 1]))
                    palindrome[i][j] = true;
            }
        }

        // 字符串s的回文子串最大也只能是字符串的长度，这里都默认初始化为最大值。
        vector<int> dp(length, length);
        for (int i = 0; i < length; i++) {
            // 如果子串s[0,i]本身就是回文的，就不需要分隔。
            if (palindrome[0][i]) {
                dp[i] = 0;
            } else {
                // 否则就要分隔，找出最小的分隔方案
                for (int j = 0; j <= i; ++j) {
                    if (palindrome[j][i])
                        dp[i] = min(dp[i], dp[j - 1] + 1);
                }
            }
        }
        return dp[length - 1];
    }

Python：

def minCut(self, s: str) -> int:
    length = len(s)
    # 判断子串[i…j]是否是回文串
    palindrome = [[False] * length for _ in range(length)]
    for j in range(length):
        for i in range(j + 1):
            # 如果i和j指向的字符不一样，那么dp[i][j]就不能构成回文字符串。
            if s[i] == s[j] and (j - i <= 2 or palindrome[i + 1][j - 1]):
                palindrome[i][j] = True

    dp = [length] * length
    for i in range(length):
        # 如果子串s[0, i]本身就是回文的，就不需要分隔。
        if palindrome[0][i]:
            dp[i] = 0
        else:
            # 否则就要分隔，找出最小的分隔方案
            for j in range(i + 1):
                if palindrome[j][i]:
                    dp[i] = min(dp[i], dp[j - 1] + 1)
    return dp[length - 1]

笔者简介

博哥，真名：王一博，毕业十多年，《算法秘籍》作者，专注于数据结构和算法的讲解，在全球30多个算法网站中累计做题2000多道，在公众号中写算法题解800多题，对算法题有自己独特的解题思路和解题技巧，喜欢的可以给个关注，也可以下载我整理的1000多页的PDF算法文档。

• 《征服数据结构》目录
  

• 《经典图论算法》目录

• 《经典图论算法》图的介绍

• 《经典图论算法》迪杰斯特拉算法(Dijkstra)