Given a string S and a string T, count the number of distinct subsequences of T in S.
A subsequence of a string is a new string which is formed from the original string by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. (ie, "ACE"
is a subsequence of "ABCDE"
while "AEC"
is not).
Here is an example:
S = "rabbbit"
, T = "rabbit"
Return 3
.
读到题又完全不知所云, 勉强能看懂的就是找S中有多少个保持原来顺序的subsequence能等于T,
看了很多大牛的博客, 终于明白了,
新建一个二维数组 dp[S.length() + 1][T.length() + 1]
dp[i][j]表示在S[0....i]T[0....j]范围内的有效Distinct Subsequence数目,
如何初始化?
对于S的每一位,i, 当T为空时, 都有一个有效解 --》 T == “”, 所以 for(i = 1 ~ s.length()), dp[ i ] [ 0 ] = 1
对于S为空, T为空, T本身就是S的一个有效解, 所以 dp[0][0] = 1;
对于T的每一位, 当S为空, 不存在任何subsequence, 所以 for(j = 1 ~ t.length()), dp[0][j] = 0;
那么怎样从以前的历史数据推出来dp[i][j]呢?
对于S.charAt( i ) 和 T.charAt( j ), 只有两种情况, 要么相同, 要么不同
为了方便理解, 就拿S和T的最后一位来举例:
不同:
S:*******B
0 1 2 3 4 5 6 7 8
i
T: **A
0 1 2
j
不同的时候比较简单, S加上第 j 位的B和不加第 j 位的 B, 对解没有影响,当前位置的有效解数目 等于 T 对应于 B 之前(0 ~ 7)的子序列的有效解数目: dp[i][j] = dp[i - 1][j]
相同:
S:*******A
0 1 2 3 4 5 6 7 8
i
T: **A
0 1 2
j
相同的时候有两种情况:
1), T 的 A 和 S 的 A match, 配成一对, 那么此时就要看 T 的 [0, 1]在 S 的 [0 ~ 7]中有多少个配对, dp[i - 1][j - 1]
2), T 的 [0 ~ 2 ]和 S 的 [0 ~ 7]之间去配对, dp[i - 1][j]
所以字符相同时 dp[i][j]= dp[i - 1][j - 1] + dp[i - 1][j]
时间复杂度是O(m + n)
空间复杂度是O(m * n)
实现时注意 i j 的取值 和 String中下标的对应关系
public class Solution {
public int numDistinct(String s, String t) {
if(s == null){
return 0;
}
if(t == null){
return 1;
}
int[][] dp = new int[s.length() + 1][t.length() + 1];
// dp[0][0] == 1, 空string有一个空string作为subsequence
for(int i = 0; i < s.length(); i++){
dp[i][0] = 1;
}
for(int i = 1; i < t.length(); i++){
dp[0][i] = 0;
}
for(int i = 1; i <= s.length(); i++ ){
for(int j = 1; j <= t.length(); j++){
// if(s.charAt(i) != t.charAt(j)) {
if(s.charAt(i - 1) != t.charAt(j - 1)){
dp[i][j] = dp[i - 1][j];
}else{
dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];
}
}
}
return dp[s.length()][t.length()];
}
}
接下来考虑一下省空间, dp[i][j]仅由 dp[i - 1][j]和 dp[i - 1][j - 1]决定,也就是只由上一行决定
优化到滚动数组是可以实现的
下面的解只是吧上面解的一行拿出来做一维数组, 两个一维数组来回赋值, 注意一维数组的第一个元素是1, dp[0]= 1, 对应于上面的初始化dp[i][0]= 1
public class Solution {
public int numDistinct(String s, String t) {
if(s == null){
return 0;
}
if(t == null){
return 1;
}
int[] dp = new int[t.length() + 1];
dp[0] = 1; // 对应之前的dp[i][0] = 1
for(int i = 1; i <= s.length(); i++ ){
int [] newline = new int[t.length() + 1];
newline[0] = 1; // 对应之前的dp[i][0] = 1
for(int j = 1; j <= t.length(); j++){
if(s.charAt(i - 1) != t.charAt(j - 1)){
newline[j] = dp[j];
}else{
newline[j] = dp[j - 1] + dp[j];
}
}
dp = newline;
}
return dp[t.length()];
}
}
那能不能再优化呢?
当然可以, 一般两个数组都可以优化成只用一个数组,
如果仍然从左往右loop, 因为dp[j] 的值取决于 上一行历史信息中的 dp[j]和 dp[j - 1], 所以写入dp[j]会覆盖 j 位置的历史信息, 导致 求 dp[j + 1]的时候所需的dp[j]不是正确值,
有两种方法,
一种是把 历史信息中的 dp[j]用一个变量cache起来, 然后求dp[j + 1]的时候 dp[j+ 1] = dp[j + 1]+ cache,
另一种方法是 因为 dp[j]只由 j 位置 和 j - 1位置的历史信息决定, 所以从后往前loop是不会覆盖历史信息的
解法如下:
public class Solution {
public int numDistinct(String s, String t) {
if(s == null){
return 0;
}
if(t == null){
return 1;
}
int[] dp = new int[t.length() + 1];
dp[0] = 1; // 对应之前的dp[i][0] = 1
for(int i = 1; i <= s.length(); i++ ){
for(int j = t.length(); j >= 1; j--){
if(s.charAt(i - 1) != t.charAt(j - 1)){
dp[j] = dp[j];
}else{
dp[j] = dp[j - 1] + dp[j];
}
}
}
return dp[t.length()];
}
}