算法 - 双指针 + 动态规划 - 392. 判断子序列 基础&进阶双解

392. 判断子序列

说明

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

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

进阶：

如果有大量输入的 S，称作 S1, S2, ... , Sk 其中 k >= 10亿，你需要依次检查它们是否为 T 的子序列。在这种情况下，你会怎样改变代码？

致谢：

特别感谢 @pbrother 添加此问题并且创建所有测试用例。

 

示例 1：

输入：s = "abc", t = "ahbgdc"
输出：true
示例 2：

输入：s = "axc", t = "ahbgdc"
输出：false
 

提示：

0 <= s.length <= 100
0 <= t.length <= 10^4
两个字符串都只由小写字符组成。

题解思路

双指针

• 只有一次判断的情况，就依照题意进行模拟
  • 准备两个指针，一个指向s，一个指向t
  • 如果s的当前字符和t的当前字符相同，则两个指针都向后移一位
  • 如果s的当前字符和t的当前字符不同，则只移动t的指针
  • s或者t遍历完成时退出循环
  • 如果s遍历完成，则返回true
  • 反之说明一直到t遍历结束也没有按序找全s的所有字符，返回false
• 时间复杂度：O(m+n)
• 空间复杂度：O(1)

进阶：二维后缀数组

• 题意说有个进阶的情况：如果有大量输入的 S，称作 S1, S2, ... , Sk 其中 k >= 10亿，你需要依次检查它们是否为 T 的子序列。在这种情况下，你会怎样改变代码？
• 还用上面的双指针算法的话
  • 时间复杂度会达到O((m+n)*k)，题意0 <= n <= 10^4、0 <= k <= 10^9
  • 这个复杂度就很大了，应当进行优化
• 看到这种极多源参数对应同一个目标模板的情况，首先想到的是应该将target的特征进行提取，后续s直接和特征进行比对，用空间换时间
• 特征的选择：
  • 起初想的是用hash表。。但是发现key为字母、value为下标的情况，对于重复字母的应对比较难，而且字母仅有26种，并无法发挥hash表的优势(这种情况用一个26长度的数组就行了)，所以放弃hash表
  • 然后借鉴前缀状态数组的思想，在上面双指针的遍历过程中，其实t已经遍历过的部分是没有意义的，可以根据t的每一个下标定义一个状态，此状态记录此下标后每个字母的出现位置
  • 相当于做一个跳表，匹配时根据当前元素判断出接下来该跳到哪一行进行下一步匹配
  • 构建t的后缀二维数组（y轴为t的长度，x轴为字母序）
  • 数组的每一行代表：当前index其后的每个字母最近的位置，不存在的都赋值-1
  • 这样就会得到target每一位的后缀状态
• 匹配方式
  • 遍历s，根据当前字符在t的后缀状态数组中查找
  • 如果存在，则将行指针跳向该index后，等待下一轮匹配
  • 否则直接返回false
  • 当遍历完成时，即为匹配成功
• k次调用时间复杂度：O(m*k), m为s的长度0 <= s.length <= 100, k为s的个数0 <= k <= 10^9
• 空间复杂度：O(n)，n为t的长度0 <= t.length <= 10^4

Code

双指针

class Solution {
    public boolean isSubsequence(String s, String t) {
        int sLen = s.length(), tLen = t.length();
        int sp = 0, tp = 0;
        while(sp < sLen && tp < tLen){
            // 如果遇到相同字符串，则指针都向后移
            if(s.charAt(sp) == t.charAt(tp)){
                sp++;
            }
            // 否则，只移动目标指针
            tp++;
        }
        // 最后判断sp有没有遍历完成
        return sp == sLen;
    }
}

进阶：二维后缀数组

class Solution {

    // t的后缀二维数组
    private int[][] ta = null;

    public boolean isSubsequence(String s, String t) {
        if (ta == null){
            init(t.toCharArray());
        }
        // 匹配
        int p = 0;
        if(s.length() > ta.length) return false;
        for(int i = 0; i < s.length(); i++){
            int c = s.charAt(i) - 'a';
            // 没有匹配到
            if(ta[p][c] == -1){
                return false;
            }
            // 指针跳跃至刚刚匹配的位置后
            p = ta[p][c] + 1;
        }
        return true;
    }

    private void init(char[] t){
        // 构建t的后缀二维数组（y轴为t的长度，x轴为字母序）
        // 数组的每一行代表：当前index其后的每个字母最近的位置
        ta = new int[t.length + 1][26];
        // 最后一行，先给个初值(意义是最后一个字符后，没有任何一个字符)
        for(int x = 0; x < 26; x++){
            ta[t.length][x] = -1;
        }
        // 从后往前遍历, 记录每个位置的字母
        for(int y = t.length - 1; y >= 0; y--){
            int p = t[y] - 'a';
            for(int x = 0; x < 26; x++){
                if(x == p){
                    ta[y][x] = y;
                    continue;
                }
                ta[y][x] = ta[y+1][x];
            }
        }

    }
}