年薪30万已成白菜价？国内10家头部互联网校招薪资一览！

以前我一直认为年薪30w已经很高了，最近在脉脉上看到很多网友把年薪30万说成白菜价，不得不感慨现在互联网大厂给的工资是真高，怪不得张雪峰建议大家报计算机专业。

曾经网上流传这样几句话：穷学计算机，富学金融，智商有余学数学，超级有钱学哲学，想要温饱学师范，想要发财当网红，生化环材四大天坑，机械土木左右护法……。计算机专业真的是穷人家孩子最好的选择。

下面是从OfferShow上查找的国内10家头部互联网的校招薪资，分别是华为，字节，腾讯，阿里，拼多多，百度，小红书，小米，美团，京东。发现对于这些大厂来说年薪30万真的不算啥（这里只统计计算机行业的），基本上大多数都能达到，怪不得年薪30万被人说成白菜价。

--------------------刷题时间到--------------------

聊完了薪资，我们再来看一道算法题，这题是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 个字符分割的最小次数，那么最后的结果就是dp[n-1]，n是字符串的长度。

对于第 i 个字符，我们首先判断字符串s[0,i]是否是回文串，如果是回文串，则不需要分割，所以dp[i]=0。

如果字符串s[0,i]不是回文串，就要分割，只需要在这个字符串中找到一个下标 j ，判断子串s[j,i]是否是回文串，如果是回文串，我们可以把字符串s[0,i]分割成s[0,j-1]和s[j,i]，所以可以得到dp[i]=dp[j-1]+1，表示进行了一次分割。

这里 j 的下标我们可以从 0 到 i 一个个枚举，只需要保存最小值即可，也就是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++) {
            // 如果i和j指向的字符不一样，那么dp[i][j]就不能构成回文字符串。
            if (s.charAt(i) != s.charAt(j))
                continue;
            palindrome[i][j] = j - i <= 2 || palindrome[i + 1][j - 1];
        }
    }

    // 字符串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.size();
        // 字符串s的回文子串最大也只能是字符串的长度，这里都默认初始化为最大值。
        vector<int> dp(length, 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++) {
                // 如果i和j指向的字符不一样，那么dp[i][j]就不能构成回文字符串。
                if (s[i] != s[j])
                    continue;
                palindrome[i][j] = j - i <= 2 || palindrome[i + 1][j - 1];
            }
        }

        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];
    }

C：

int min(int a, int b) {
    return a > b ? b : a;
}

int minCut(char* s) {
    int length = strlen(s);
    int dp[length];
    // 判断子串[i…j]是否是回文串
    bool palindrome[length][length];
    memset(palindrome,0,sizeof(palindrome));
    for (int j = 0; j < length; j++) {
        for (int i = 0; i <= j; i++) {
            // 如果i和j指向的字符不一样，那么dp[i][j]就不能构成回文字符串。
            if (s[i] != s[j])
                continue;
            palindrome[i][j] = j - i <= 2 || palindrome[i + 1][j - 1];
        }
    }

    // 字符串s的回文子串最大也只能是字符串的长度，这里都默认初始化为最大值。
    for(int i = 0; i < length; i++)
        dp[i] = length;  // 初始化数组元素为1到5

    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)
    dp = [length] * length
    # 判断子串[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]:
                continue;
            palindrome[i][j] = j - i <= 2 or palindrome[i + 1][j - 1];
    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];

JS：

var minCut = function (s) {
    const length = s.length;
    const dp = new Array(length).fill(length);
    // 判断子串[i…j]是否是回文串
    const palindrome = new Array(length).fill(0).map(() => new Array(length).fill(false));
    for (let j = 0; j < length; j++) {
        for (let i = 0; i <= j; i++) {
            // 如果i和j指向的字符不一样，那么dp[i][j]就不能构成回文字符串。
            if (s[i] !== s[j])
                continue;
            palindrome[i][j] = j - i <= 2 || palindrome[i + 1][j - 1];
        }
    }

    for (let i = 0; i < length; i++) {
        // 如果子串s[0,i]本身就是回文的，就不需要分隔。
        if (palindrome[0][i]) {
            dp[i] = 0;
        } else {
            // 否则就要分隔，找出最小的分隔方案
            for (let j = 0; j <= i; ++j) {
                if (palindrome[j][i])
                    dp[i] = Math.min(dp[i], dp[j - 1] + 1);
            }
        }
    }
    return dp[length - 1];
};

笔者简介

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

• 耗时两年终于出版了！

• 华为今年的校招薪资，最高年薪90万。。。

• 2023年全球程序员薪酬报告出炉，北京年收入60多万排在亚洲第6。。。

• 字节今年的校招薪资。。。

• 腾讯今年的校招薪资。。。