LeetCode115.不同的子序列---动态规划题解

LeetCode 115.不同的子序列

给定一个字符串 s 和一个字符串 t ，计算在 s 的子序列中 t 出现的个数。

字符串的一个 子序列 是指，通过删除一些（也可以不删除）字符且不干扰剩余字符相对位置所组成的新字符串。（例如，“ACE” 是 “ABCDE” 的一个子序列，而 “AEC” 不是）

题目数据保证答案符合 32 位带符号整数范围。

示例 1：

输入：s = “rabbbit”, t = “rabbit”
输出：3
解释：
如下图所示, 有 3 种可以从 s 中得到 “rabbit” 的方案。
rabbbit
rabbbit

解答

看到子序列，容易想到1143. 最长公共子序列等子序列问题。使用动态规划解法。分为 4 步。

1、状态定义(集合、属性) 2、状态计算 3、判断遍历顺序 4、初始化

1. 状态定义

一般靠经验(猜)。本题与最长公共子序列问题类似，题目给出两个字符串 s , t，需要定义二维数组。

int[][] f = new int[lens][lent];

最长公共子序列问题的状态定义为：

f[i][j] 代表字符串 s 的前 i 个字符，与 字符串 t 的前 j 个字符，能够组成公共子序列的方式的集合，f[i][j]存储的值(属性)为最大值。

f[i][j]代表前 i / j 个字符，不能确定字符串 s 的第 i 个字符 / 字符串 t 的第 j 个字符是否是构成最长公共子序列的一部分。

因为本题要求 t 的每一个字符都要被用到。所以将其状态定义放在本题中不能直接套用，要进行修改。

本题状态定义为：

f[i][j]代表字符串 s 的前 i 个字符，能组成字符串 t 的 1-j 子字符串的方式的集合，属性为个数 cnt。

2. 状态计算

分情况讨论

设字符串 s 的第 i 个字符为 cs，t 的第 j 个字符为 ct。

所以对于 f[i][j]的计算，通常分为四种情况：1.不选 cs，不选 ct 2.不选 cs，选 ct 3.选 cs，不选 ct 4.选 cs，选 ct

因为 ct 是一定要选的。所以只剩两种情况：2,4。

状态转移

首先：f[i][j] = f[i - 1][j]。根据状态定义，f[i][j] 包含 f[i - 1][j]。

2：不选 cs，选 ct。字符串 s 的前 i - 1 个字符，能够组成字符串 t 的 1-j 子字符串的方式的个数。即f[i][j] = f[i - 1][j]:

4: 选cs，选 ct。两个都选只有在 cs == ct的情况下，两个都选和两个都不选的选法个数相同。即f[i][j] = f[i - 1][j - 1]

如果无法理解，回去仔细看状态定义。

总结状态计算：

f[i][j] = f[i - 1][j]; 
if(cs == ct){
	f[i][j] += f[i - 1][j - 1];
}

3. 遍历顺序

状态计算时，f[i][j]是由 f[i - 1][j - 1]，f[i - 1][j] 转移而来的。所以 i，j 都需要从小到大顺序遍历。

4. 初始化

因为状态计算需要用到 i - 1。所以 i 需要从 1 开始，防止数组越界。

int[][] f = new int[lens + 1][lent + 1];

判断三种个特殊情况，1.字符串 s 为空串。字符串 t 为空串。即 f[0][0] = 1。

2.字符串 s 为空串，字符串 t 不为空串。那么 s 的子序列无法组成 t。Arrays.fill(f[0],0);

3.字符串 s 不为空串，字符串 t 为空串。那么 s 的子序列中，只有一种情况能够组成 t。

for(int i = 1; i <= lens; i++) f[i][0] = 1;

总结初始化语句：

int[][] f = new int[lens + 1][lent + 1];
//初始化考虑特例情况，当 s 为空，t为空
f[0][0] = 1;
//当 s 为空，t不为空
Arrays.fill(f[0],0);
f[0][0] = 1;
//当 s 不为空，t为空，只有一种方式 --> 不选 s 任意一个字符所组成的子序列
for(int i = 1; i <= lens; i++) f[i][0] = 1;

Java 代码(含注释)

class Solution {
    public int numDistinct(String s, String t) {
        int lens = s.length();
        int lent = t.length();
        if(lens < lent) return 0;
        if(s.equals(t)) return 1;
        char[] css = s.toCharArray();
        char[] cst = t.toCharArray();

        //f[i][j] s 前i个字符中，组成 t 字符串的 1-j 子串的方式
        //属性是数量 cnt
        //对于 f[i][j] 
        //if c1 == c2 f[i][j] = f[i - 1][j - 1] + f[i - 1][j]
        //else f[i][j] = f[i - 1][j]
        int[][] f = new int[lens + 1][lent + 1];
        //初始化考虑特例情况，当 s 为空，t为空
        f[0][0] = 1;
        //当 s 为空，t不为空
        Arrays.fill(f[0],0);
        f[0][0] = 1;
        //当 s 不为空，t为空，只有一种方式 --> 不选 s 任意一个字符所组成的子序列
        for(int i = 1; i <= lens; i++) f[i][0] = 1;

        for(int i = 1; i <= lens; i++){
            char cs = css[i - 1];
            for(int j = 1; j <= lent; j++){
                char ct = cst[j - 1];
                f[i][j] = f[i - 1][j];
                if(cs == ct){
                    f[i][j] += f[i - 1][j - 1];
                }
            }
        }

        return f[lens][lent];
    }
}