【双指针】392. 判断子序列【简单】-CSDN博客

本文链接：https://blog.csdn.net/FLGBgo/article/details/138708034

判断子序列

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

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

进阶：

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

解题思路

为了判断字符串 s 是否为字符串 t 的子序列，可以使用双指针技巧。

1、将两个指针分别指向字符串 s 和 t 的开头，然后逐个字符地比较，如果字符相等，则将两个指针都向后移动；
2、如果不相等，则只将指针指向字符串 t 的指针向后移动。
3、最后，如果字符串 s 的指针遍历完毕，则说明 s 是 t 的子序列，返回 true；否则，返回 false。

Java实现

public class IsSubsequence {
    public boolean isSubsequence(String s, String t) {
        int i = 0, j = 0;
        while (i < s.length() && j < t.length()) {
            if (s.charAt(i) == t.charAt(j)) {
                i++;
            }
            j++;
        }
        return i == s.length();
    }


    public static void main(String[] args) {
        IsSubsequence isSubsequence = new IsSubsequence();
        String s1 = "abc", t1 = "ahbgdc";
        System.out.println("Is Subsequence: " + isSubsequence.isSubsequence(s1, t1)); // Expected: true

        String s2 = "axc", t2 = "ahbgdc";
        System.out.println("Is Subsequence: " + isSubsequence.isSubsequence(s2, t2)); // Expected: false
    }
}

时间空间复杂度

时间复杂度：在最坏情况下，时间复杂度为 O(max(m, n))，其中 n 是字符串 s 的长度，m 是字符串 t 的长度。
空间复杂度：使用了常数级的额外空间，空间复杂度为 O(1)。

进阶解题思路

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

在这种情况下，我们需要考虑优化算法以提高效率，因为有大量输入的 S 需要逐个检查是否为 T 的子序列。

可以考虑使用预处理的方法来加速匹配过程。
1、一种可行的方法是对字符串 T 进行预处理，构建一个哈希表或者数组，其中键或者索引表示字符，值表示在字符串 T 中出现该字符的所有位置。
2、对于每个输入的字符串 S，可以遍历其字符，并在预处理的哈希表或数组中查找下一个字符的位置。
3、如果找到了，则更新当前位置，继续查找下一个字符。
4、如果遍历完字符串 S 后，能够成功找到每个字符的位置，则说明 S 是 T 的子序列。

这种预处理的方法可以大大减少每次检查的时间复杂度，因为在预处理过程中可以一次性获取到每个字符在字符串 T中的所有位置，而在检查过程中只需要根据当前字符在哈希表或数组中查找下一个位置即可，无需重新遍历字符串 T。

进阶Java实现

public class IsSubsequenceAdvanced {
    //预处理map
    Map<Character, List<Integer>> map = new HashMap<>();

    //初始化map,只需要处理一次
    public void initTarget(String t){
        //预处理字符串 T，构建字符位置哈希表
        for (int i = 0; i < t.length(); i++) {
            char ch = t.charAt(i);
            if (!map.containsKey(ch)) {
                map.put(ch, new ArrayList<>());
            }
            map.get(ch).add(i);
        }
    }

    //进行字符串匹配
    public boolean isSubsequenceAdvanced (String s) {

        int prevIndex = -1; // 上一个字符的位置
        // 遍历字符串 S，并根据预处理的哈希表查找下一个字符的位置
        for (char ch : s.toCharArray()) {
            if (!map.containsKey(ch)) {
                return false; // 字符不存在于字符串 T 中，直接返回 false
            }
            List<Integer> positions = map.get(ch);
            // 在当前字符的位置列表中查找大于上一个字符位置的最小位置
            int nextIndex = binarySearch(positions, prevIndex);
            if (nextIndex == -1) {
                return false; // 找不到大于上一个字符位置的位置，直接返回 false
            }
            prevIndex = nextIndex;
        }
        return true;
    }

    // 二分查找大于给定位置的最小位置
    private int binarySearch(List<Integer> positions, int target) {
        int left = 0, right = positions.size() - 1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (positions.get(mid) <= target) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return left < positions.size() ? positions.get(left) : -1;
    }

    public static void main(String[] args) {
        IsSubsequenceAdvanced isSubsequence = new IsSubsequenceAdvanced();
        String s1 = "abc",s2="hgc", t1 = "ahbgdc";
        isSubsequence.initTarget(t1);
        // Expected: true
        System.out.println(isSubsequence.isSubsequenceAdvanced(s1));
        // Expected: true
        System.out.println(isSubsequence.isSubsequenceAdvanced(s2));
    }
}