中概财报集体亮眼
虽然最近几天恒指(港股)稍有回落,但年线仍有 9% 的上涨。
过去三年,恒指分别下跌 14.08%、15.46% 和 13.82%。
而在近期,国内各大互联网都公布了财报,别看各个大厂的作妖不断,但这次似乎真的有点「否极泰来」的意思了:
-
腾讯净利润 418.89 亿,同比增长 62.12%
-
拼多多净利润 279.98 亿,同比增长 245.61%
-
阿里净利润 244.18 亿,同比增长 -10.80%
-
网易净利润 76.34 亿,同比增长 13.02%
-
京东净利润 71.30 亿,同比增长 13.88%
-
小米净利润 64.9 亿,同比增长 100%
-
百度净利润 54.48 亿,同比增长 -6.47%
-
携程净利润 43.12 亿,同比增长 27.76%
-
快手净利润 41.19 亿,同比增长 571.82%
现在提到「互联网」和「计算机」,大多数声音还都是「裁员」、「人挤人」和「找不到工作」,但财务数据才是真实的,而且从「金融资本市场」到「劳动力市场」往往有 1~2 年的滞后性。
现在往回看,其实国内互联网的转向是从 2021 年年初就开始的,但 2021 年的招聘市场,大家都知道的。流行语是「打得火热」、「跳槽薪资翻倍」和「应届生实习工资水涨船高,直接倒挂老员工」,所谓的「裁员」和「寒气」是从 2022 下半年才开始大面积盛行的。
所以根据现在掌握的信息来看,我可以大胆给出结论:计算机看不到希望的长夜已经过去,回暖是大概率的事情。
我给大家的建议,抓紧学习,厚积薄发,好日子快回来了。
如果因为现在的行情决定「转行」或者「放弃转码」,大概率不会变得更好,而且可能还会成为倒在黎明的那一批。
...
回归主题。
来一道和「字节跳动」相关的题目(不要问我为啥最近都是字节跳动,宇宙厂的投稿太多了 🤣
题目描述
平台:LeetCode
题号:940
给定一个字符串 s
,计算 s
的 不同非空子序列 的个数。
因为结果可能很大,所以返回答案需要对 取余 。
字符串的 子序列 是经由原字符串删除一些(也可能不删除)字符但不改变剩余字符相对位置的一个新字符串。
例如,"ace"
是 "abcde"
的一个子序列,但 "aec"
不是。
示例 1:
输入:s = "abc"
输出:7
解释:7 个不同的子序列分别是 "a", "b", "c", "ab", "ac", "bc", 以及 "abc"。
示例 2:
输入:s = "aba"
输出:6
解释:6 个不同的子序列分别是 "a", "b", "ab", "ba", "aa" 以及 "aba"。
示例 3:
输入:s = "aaa"
输出:3
解释:3 个不同的子序列分别是 "a", "aa" 以及 "aaa"。
提示:
-
-
s
仅由小写英文字母组成
序列 DP
为了方便,我们令 s
下标从 1
开始,定义 为考虑前 i
个字符,且结尾字符为 j
的不同子序列的个数,其中 j
的范围为 代指小写字符 a-z
。
我们有显而易见的初始化条件 ,最终答案为 。
不失一般性考虑 该如何转移,根据 是否为 j
进行分情况讨论:
-
: 由于状态定义限定了结尾字符必须是 ,因而 必然不会用到,此时有:
-
: 此时 可作为结尾元素,同时由于我们统计的是「不同」的子序列个数,因而「以 结尾的子序列方案数」与「以 结尾的子序列方案数」完全等价。 对于以 作为子序列结尾字符的方案数,容易想到其方案数等于「 单独作为子序列」+「 拼接在其余子序列后面形成新子序列」,即有:
Java 代码:
class Solution {
int MOD = (int)1e9+7;
public int distinctSubseqII(String s) {
int n = s.length(), ans = 0;
int[][] f = new int[n + 1][26];
for (int i = 1; i <= n; i++) {
int c = s.charAt(i - 1) - 'a';
for (int j = 0; j < 26; j++) {
if (c != j) {
f[i][j] = f[i - 1][j];
} else {
int cur = 1;
for (int k = 0; k < 26; k++) cur = (cur + f[i - 1][k]) % MOD;
f[i][j] = cur;
}
}
}
for (int i = 0; i < 26; i++) ans = (ans + f[n][i]) % MOD;
return ans;
}
}
C++ 代码:
class Solution {
public:
int distinctSubseqII(string s) {
int n = s.length(), MOD = 1e9 + 7;
vector<vector<int>> f(n + 1, vector<int>(26, 0));
for (int i = 1; i <= n; ++i) {
int c = s[i - 1] - 'a';
for (int j = 0; j < 26; ++j) {
if (c != j) {
f[i][j] = f[i - 1][j];
} else {
int cur = 1;
for (int k = 0; k < 26; ++k) cur = (cur + f[i - 1][k]) % MOD;
f[i][j] = cur;
}
}
}
int ans = 0;
for (int i = 0; i < 26; ++i) ans = (ans + f[n][i]) % MOD;
return ans;
}
};
Python 代码:
class Solution:
def distinctSubseqII(self, s: str) -> int:
n, MOD = len(s), 1e9+7
f = [[0] * 26 for _ in range(n + 1)]
for i in range(1, n + 1):
c = ord(s[i - 1]) - ord('a')
for j in range(26):
f[i][j] = f[i - 1][j] if c != j else (1 + sum(f[i - 1])) % MOD
return int(sum(f[n]) % MOD)
TypeScript 代码:
function distinctSubseqII(s: string): number {
const MOD = 1e9+7
let n = s.length, ans = 0
const f = new Array<Array<number>>(n + 1)
for (let i = 0; i <= n; i++) f[i] = new Array<number>(26).fill(0)
for (let i = 1; i <= n; i++) {
const c = s.charCodeAt(i - 1) - 'a'.charCodeAt(0)
for (let j = 0; j < 26; j++) {
if (c != j) {
f[i][j] = f[i - 1][j]
} else {
let cur = 1
for (let k = 0; k < 26; k++) cur = (cur + f[i - 1][k]) % MOD
f[i][j] = cur
}
}
}
for (let i = 0; i < 26; i++) ans = (ans + f[n][i]) % MOD
return ans
}
-
时间复杂度: ,其中 为字符集大小 -
空间复杂度:
转移优化
根据转移的依赖关系,实现上,我们并不需要真正记录每一个 ,而可以直接记录一个总的不同子序列方案数 ans
。
这可以避免每次计算新状态时,都累加前一个 的值,有效减低时空复杂度。
Java 代码:
class Solution {
int MOD = (int)1e9+7;
public int distinctSubseqII(String s) {
int n = s.length(), ans = 0;
int[] f = new int[26];
for (int i = 0; i < n; i++) {
int c = s.charAt(i) - 'a', prev = f[c];
f[c] = (ans + 1) % MOD;
ans = (ans + f[c]) % MOD;
ans = (ans - prev + MOD) % MOD;
}
return ans;
}
}
C++ 代码:
class Solution {
public:
int distinctSubseqII(string s) {
int n = s.length(), ans = 0, MOD = 1e9 + 7;
vector<int> f(26, 0);
for (int i = 0; i < n; ++i) {
int c = s[i] - 'a', prev = f[c];
f[c] = (ans + 1) % MOD;
ans = (ans + f[c]) % MOD;
ans = (ans - prev + MOD) % MOD;
}
return ans;
}
};
Python 代码:
class Solution:
def distinctSubseqII(self, s: str) -> int:
n, MOD, ans = len(s), 1e9+7, 0
f = [0] * 26
for i in range(n):
c = ord(s[i]) - ord('a')
prev = f[c]
f[c] = (ans + 1) % MOD
ans = (ans + f[c] - prev) % MOD
return int(ans)
TypeScript 代码:
function distinctSubseqII(s: string): number {
const MOD = 1e9+7
let n = s.length, ans = 0
const f = new Array<number>(26).fill(0)
for (let i = 0; i < n; i++) {
const c = s.charCodeAt(i) - 'a'.charCodeAt(0), prev = f[c]
f[c] = (ans + 1) % MOD
ans = (ans + f[c]) % MOD
ans = (ans - prev + MOD) % MOD
}
return ans
}
-
时间复杂度: -
空间复杂度:
最后
给大伙通知一下 📢 :
全网最低价 LeetCode 会员目前仍可用 ~
📅 年度会员:有效期加赠两个月!!; 季度会员:有效期加赠两周!!
🧧 年度会员:获 66.66 现金红包!!; 季度会员:获 22.22 现金红包!!
🎁 年度会员:参与当月丰厚专属实物抽奖(中奖率 > 30%)!!
专属链接:leetcode.cn/premium/?promoChannel=acoier
我是宫水三叶,每天都会分享算法知识,并和大家聊聊近期的所见所闻。
欢迎关注,明天见。
更多更全更热门的「笔试/面试」相关资料可访问排版精美的 合集新基地 🎉🎉
本文由 mdnice 多平台发布