共计 3025 个字符，预计需要花费 8 分钟才能阅读完成。
题目形容
这是 LeetCode 上的 940. 不同的子序列 II，难度为 艰难 。
Tag :「序列 DP」、「动静布局」
给定一个字符串 s，计算 s 的 不同非空子序列 的个数。因为后果可能很大，所以返回答案须要对 $10^9 + 7$ 取余。
字符串的 子序列 是经由原字符串删除一些（也可能不删除）字符但不扭转残余字符绝对地位的一个新字符串。
例如，"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"。提醒：
- $1 <= s.length <= 2000$
s仅由小写英文字母组成
序列 DP
为了不便，咱们令 s 下标从 $1$ 开始，定义 $f[i][j]$ 为思考前 $i$ 个字符，且结尾字符为 $j$ 的不同子序列的个数，其中 $j$ 的范畴为 $[0, 25]$ 代指小写字符 a-z。
咱们有不言而喻的初始化条件 $f[0][X] = 0$，最终答案为 $\sum_{i = 0}^{25}f[n][i]$。
不失一般性思考 $f[i][j]$ 该如何转移，依据 $s[i]$ 是否为 $j$ 进行分状况探讨：
- $s[i] \neq j$ : 因为状态定义限定了结尾字符必须是 $j$，因此 $s[i]$ 必然不会用到，此时有：
$$
f[i][j] = f[i – 1][j]
$$
- $s[i] = j$ : 此时 $s[i]$ 可作为结尾元素，同时因为咱们统计的是「不同」的子序列个数，因此「以 $j$ 结尾的子序列计划数」与「以 $s[i]$ 结尾的子序列计划数」齐全等价。
对于以 $s[i]$ 作为子序列结尾字符的计划数，容易想到其计划数等于「$s[i]$ 独自作为子序列」+「$s[i]$ 拼接在其余子序列前面造成新子序列」，即有：
$$
f[i][j] = 1 + \sum_{k = 0}^{25} f[i – 1][k]
$$
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;
}
}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
}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)- 工夫复杂度：$O(n \times C^2)$，其中 $C = 26$ 为字符集大小
- 空间复杂度：$O(n \times C)$
转移优化
依据转移的依赖关系，实现上，咱们并不需要真正记录每一个 $f[i][X]$，而能够间接记录一个总的不同子序列计划数 ans。
这能够防止每次计算新状态时，都累加前一个 $f[i – 1][X]$ 的值，无效减低时空复杂度。
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;
f = (ans + 1) % MOD;
ans = (ans + f) % MOD;
ans = (ans - prev + MOD) % MOD;
}
return 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
f = (ans + 1) % MOD
ans = (ans + f) % 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
f = (ans + 1) % MOD
ans = (ans + f - prev) % MOD
return int(ans)- 工夫复杂度：$O(n)$
- 空间复杂度：$O(C)$
最初
这是咱们「刷穿 LeetCode」系列文章的第 No.940 篇，系列开始于 2021/01/01，截止于起始日 LeetCode 上共有 1916 道题目，局部是有锁题，咱们将先把所有不带锁的题目刷完。
在这个系列文章外面，除了解说解题思路以外，还会尽可能给出最为简洁的代码。如果波及通解还会相应的代码模板。
为了不便各位同学可能电脑上进行调试和提交代码，我建设了相干的仓库：https://github.com/SharingSou…。
在仓库地址里，你能够看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其余优选题解。
更多更全更热门的「口试 / 面试」相干材料可拜访排版精美的 合集新基地 🎉🎉
本文由 mdnice 多平台公布
