判断子序列的三种方法

392. 判断子序列https://leetcode.cn/problems/is-subsequence/

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

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

解法1: 双指针

具体思路:通过两个指针,分别遍历两个字符串,若相同,则两个指针均向后移动一位,若不等,则判断当前不等的长串指针所指向的字符与短串的第一个字符是否相等,若相等,则将短串的下标重新置为0,最后,当长串遍历到结尾的时候,比较短串是否已经遍历到最后,若是,则为子串,返回true,否则,.返回false.

class Solution {
    public boolean isSubsequence(String s, String t) {
        //双指针
        int index = 0;
        int slen = s.length();
        int tlen = t.length();
        if (slen == 0){
            return true;
        }
        for (int i = 0; i < tlen; i++){
            if ((index < slen ) && (t.charAt(i) != s.charAt(index)) && (t.charAt(i) == s.charAt(0))){
                    index = 1;    
            }
            else if ((index < slen ) && (t.charAt(i) == s.charAt(index))){
                index += 1;
            }
        }
        System.out.println(index);
        return index == slen ;
        }
}

解法2:dp

具体思路:

1. dp[i][j]含义:代表i-1, j-1下标的两个串的最大匹配长度.
2. 递归公式:   
   1. s[i] = t[i] 则dp = dp[i-1][j-1]+1
   2. s[i] != t[i] 则需要回退,具体回退方法,以长串为列为例,需要比较s[i-1]与t[i-2]是否匹配,即删除
3. 数组初始化:dp[0][0] = 0;
4. 遍历顺序:从上到下,从左到右

class Solution {
    public int longestCommonSubsequence(String text1, String text2) {
        int[][] dp = new int[text1.length() + 1][text2.length() + 1]; 
        for (int i = 1 ; i <= text1.length() ; i++) {
            char char1 = text1.charAt(i - 1);
            for (int j = 1; j <= text2.length(); j++) {
                char char2 = text2.charAt(j - 1);
                if (char1 == char2) { 
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                } else {
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
                }
            }
        }
        return dp[text1.length()][text2.length()];
    }
}

 解法3:更一般的情况

求两个字符串的公共子序列的最大长度:

1143. 最长公共子序列https://leetcode.cn/problems/longest-common-subsequence/

给定两个字符串 text1 和 text2，返回这两个字符串的最长 公共子序列 的长度。如果不存在 公共子序列 ，返回 0 。

一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。

例如，"ace" 是 "abcde" 的子序列，但 "aec" 不是 "abcde" 的子序列。
两个字符串的 公共子序列 是这两个字符串所共同拥有的子序列。

仍然是dp解法,相比较解法2而言,若不相等的回退方向改变为向左和向上以及左上,即当s[i-1] != t[j-1]时,比较dp[i-1][j]与dp[i][j-1]并取最大的.同时用一个re来记录最大的数据.

具体代码如下:

        //dp
        //类似 1143.最长公共子序列 求两个字符串的最长公共子序列是否等于模式串即可
        int re = 0;
        int slen = s.length() + 1;
        int tlen = t.length() + 1;
        int [][] dp = new int[tlen][slen];
        for (int i = 1; i < tlen ; i++){
            for(int j = 1; j < slen; j++){
                if (s.charAt(j-1) == t.charAt(i-1)){
                    dp[i][j] = dp[i-1][j-1] + 1;
                    re = Math.max(dp[i][j], re);
                }
                else{
                    dp[i][j] = Math.max(dp[i-1][j], dp[i][j-1]);
                }
            }
        }
        return re == slen - 1;