LeetCode - Distinct Subsequences_[depthpacketstreamparser] not all subsequences rec-优快云博客

本文详细解析使用动态规划解决子序列计数问题，通过实例分析并给出代码实现，时间复杂度和空间复杂度均为O(m*n)，强调从小问题入手总结规律的重要性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

https://leetcode.com/problems/distinct-subsequences/

这道题一开始我还想用 two pointers , backtracking来做，后来想这个是算个数，backtracking太复杂了，而且也没想到很明确的做法。

后来看tag发现是DP题，分析一下：

a b c d a e b c

a 1 1 1 1 2 2 2 2

b 0 1 1 1 1 1 3 3

很明显，当dst[i][[j]表示S的（0，j）中包含的T 的（0，i）的不同子串数。

当T只有一个字符时，那么看此时S的最后一个字符和T的最后一个字符是否相同，相同的话，dst[i][j]就是dst[i][j-1]+1,否则就是dst[i][j-1]

当T不止一个字符时，同样也看此时S的最后一个字符和T的最后一个字符是否相同，相同的话，dst[i][j]就是 dst[i][j-1]+dst[i-1][j-1]，否则就是dst[i][j-1]

这是通过上面的例子总结出来的，但是如果仔细分析，会发现，此时其实是看当前S的最后一个字符能否作为当前T的子串的一部分，如果不能的话，那么情况没有任何改变，跟dst[i][j-1]，即没有这个字符时，个数一样即可。如果S的最后一个字符可以作为T的子串的话，那么除了没有这个字符时可以形成的个数dst[i][j-1]，还要加上有了这个字符时，可以形成的个数，即dst[i-1][j-1]

代码如下：

public class Solution {
    public int numDistinct(String S, String T) {
        if(S.length() <= T.length()) return S.equals(T)? 1: 0;
        int[][] dst = new int[T.length()][S.length()];
        dst[0][0] = S.charAt(0)==T.charAt(0) ? 1 : 0;
        
        for(int i=0; i<T.length(); i++){
            for(int j=i; j<S.length(); j++){
                if(i==0 && j==0) continue;
                if(i==0){
                    dst[i][j] = S.charAt(j)==T.charAt(i) ? dst[i][j-1]+1 : dst[i][j-1];
                    continue;
                }
                dst[i][j] = S.charAt(j)==T.charAt(i) ? dst[i][j-1]+dst[i-1][j-1] : dst[i][j-1];
            }
        }
        return dst[T.length()-1][S.length()-1];
    }
}

看起来代码挺少的，主要是用 ? : 运算符来减少代码行数。

时间复杂度和空间复杂度都是O(m*n)。

复杂问题一定要从小问题开始分析，总结规律，再看这个规律是否合理。