想要精通算法和SQL的成长之路 - 判断子序列问题

前言

想要精通算法和SQL的成长之路 - 系列导航

一. 判断子序列

原题链接
给定字符串 s 和 t ，判断 s 是否为 t 的子序列。

字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。

1.1 动态规划做法

这个题目其实是使用双指针会更加简单明了点的。我这里是放在动态规划里面去学习的。因此我先来说些动态规划怎么做。大家可以先看下这篇文章最长序列问题

里面对于满足以下两种条件的：

• 存在两个对象的。
• 可以删除某个字符串的（不连续）。

可以发现写的代码都是一个风格。思路：

1.我们定义dp[i][j]：在s 中以i-1为结尾。在t中以j-1为结尾的相同子序列长度。

看到这里的朋友可能想问了。最长公共子序列这个题目中，定义的是区间，为什么这里就是以xxx为结尾呢？

注意：

1. 我们不再是求得t和s的重复序列部分。而是判断s是否可以作为t的一个子序列。
2. 换句话就是，s对于最长公共共子序列这个题目来说，其长度已经定死了。我们无需关系其区间问题。

2.如果s[i] 和t[j] 相等。那么dp[i][j] = dp[i-1][j-1] +1。
3.如果s[i] 和t[j] 不相等。也就是说我们需要在t这个字符串中删除元素了。即dp[i][j] = dp[i][j-1]。

4.最终结果来看，判断子序列的标准是啥？就是相同子序列的长度(dp[i][j])等于字符串s的长度。

写成代码就是：

public boolean isSubsequence(String s, String t) {
    int[][] dp = new int[s.length() + 1][t.length() + 1];
    for (int i = 1; i <= s.length(); i++) {
        for (int j = 1; j <= t.length(); j++) {
            if (s.charAt(i - 1) == t.charAt(j - 1)) {
                dp[i][j] = dp[i - 1][j - 1] + 1;
            } else {
                dp[i][j] = dp[i][j - 1];
            }
        }
    }
    return dp[s.length()][t.length()] == s.length();
}

1.2 双指针

思路：

1. 我们定义两个下标indexS和indexT，分别在s和t中进行遍历。
2. 循环操作：如果s[indexS] 和t[indexT] 相等，那么两个指针同时往后移动。否则，移动indexT指针。
3. 循环条件：两个指针都不能越界。
4. 判断子序列条件：indexS指针到达的位置就是字符串s的长度。说明在字符串t中找到了字符串s的子序列。

public boolean isSubsequence(String s, String t) {
    int indexS = 0, indexT = 0;
    while (indexS < s.length() && indexT < t.length()) {
        if (s.charAt(indexS) == t.charAt(indexT)) {
            indexS++;
        }
        indexT++;
    }

    return indexS == s.length();
}

二. 不同的子序列

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

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

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

示例 1：

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

先小提醒一下：

• 第一题中：s是t的子序列。
• 第二题中：t是s的子序列。

思路：

1.dp[i][j]：以i-1为结尾的s子序列中出现以j-1为结尾的t的个数为dp[i][j]。

---

2.递归公式的推导。需要注意的一点就是：我们是拿 s 字符串中的字符去匹配 t 字符串。

举例：我们可以从后往前进行匹配。让可匹配的字符串越来越小。让问题缩小化。

• s：rabbb。
• t：rabb。

如果s[i] == t[j]，有两种情况：

如果s[i] != t[j]，即s[i]这个字符不能用来匹配，dp[i][j]代表的子序列个数，需要继承上一个值，即dp[i-1][j]。

那么这部分代码就是：

for (int i = 1; i <= s.length(); i++) {
    for (int j = 1; j <= t.length(); j++) {
        if (s.charAt(i - 1) == t.charAt(j - 1)) {
            dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];
        } else {
            dp[i][j] = dp[i - 1][j];
        }
    }
}

紧接着就是dp数组的初始化问题。上面的分析是将字符串缩短，从后往前进行分析的。那么缩短到一定程度，可分为两种情况：

• t（子串）变成空串了，那么s为了匹配它，只有一种情况，就是把s本身变成空串。因此方式数为1。
• s变成空串了，但是t还不是（因为设定上t是子串，t为空串的时候，s肯定不是空串），此时s无法匹配t，因此方式数为0。

即：

// s为空串，t非空，s无法匹配，方式数为0，这段代码可以不写，因为int数组默认值就是0
for (int j = 0; j < t.length(); j++) {
    dp[0][j] = 0;
}
// t为空串，s非空，s只有将其本身变空，方式数为1
for (int i = 0; i < s.length(); i++) {
    dp[i][0] = 1;
}

返回值：得到以s.len为结尾，包含子序列t的方式数。即dp[s.length()][t.length()] 。最终代码：

public int numDistinct(String s, String t) {
    int[][] dp = new int[s.length() + 1][t.length() + 1];
    // s为空串，t非空，s无法匹配，方式数为0，这段代码可以不写，因为int数组默认值就是0
    for (int j = 0; j < t.length(); j++) {
        dp[0][j] = 0;
    }
    // t为空串，s非空，s只有将其本身变空，方式数为1
    for (int i = 0; i < s.length(); i++) {
        dp[i][0] = 1;
    }
    for (int i = 1; i <= s.length(); i++) {
        for (int j = 1; j <= t.length(); j++) {
            // 如果两个元素相等
            if (s.charAt(i - 1) == t.charAt(j - 1)) {
                // 两种情况，使用s[i] 和不使用s[i] 去匹配
                dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];
            } else {
                // 否则无法匹配，继承上一个方式数
                dp[i][j] = dp[i - 1][j];
            }
        }
    }
    // 得到以 s.length() 为结尾，出现字符串t的方式数
    return dp[s.length()][t.length()];
}