leetcode(DP)--392. 判断子序列

最新推荐文章于 2021-05-26 10:33:17 发布

原创最新推荐文章于 2021-05-26 10:33:17 发布 · 232 阅读

0 ·

CC 4.0 BY-SA版权

LeetCode--DP 专栏收录该内容

1 篇文章

订阅专栏

本文详细解析LeetCode第392题“判断子序列”的三种解法：动态规划、简单遍历及利用Java内置函数IndexOf。通过具体代码示例，深入探讨每种方法的实现细节和效率对比。

leetcode(DP)–392. 判断子序列

1，题目：

在这里插入图片描述
2，思路：

方法一：动态规划：

思路：

状态：dp[i][j]为s的从头开始到i的子字符串是否为t从头开始到j的子字符串的子序列

状态转移公式：

1、当char[i]==char[j]时，则字符i一定是j的子序列，如果0_{i-1子字符串是0}j-1子字符串的子序列，则dp[i][j]=true，所以dp[i][j]= dp[i-1][j-1]；
2、当char[i]!=char[j]时，即判断当前0_{i子字符串是否是0}j-1的子字符串的子序列，即dp[i][j] =dp[i][j -1]（这里也就是移动j了，来找i对应的位置的元素和j-1时的位置的元素是否相等）。如ab，eabc，虽然s的最后一个字符和t中最后一个字符不相等，但是因为ab是eab的子序列，所以ab也是eabc的子序列
3、初始化：空字符串一定是t的子字符串的子序列，所以dp[0][j]=true
4、结果：返回dp[sLen][tLen]

方法二：简单方法（没有用动态规划）：
就是遍历s和t，然后看t中是否有s，就是简单的遍历。

方法三：用到了自带的函数IndexOf：

java中非常好的一个方法，indexOf(char c,int m)意思是从第m位置开始寻找该索引，找到则返回该索引，否则返回-1，利用该特性我们通过对索引处理从而获得解。

3，代码：

方法一：动态规划：

class Solution {
    public boolean isSubsequence(String s, String t) {

        /*动态规划：
        思路：

状态：dp[i][j]为s的从头开始到i的子字符串是否为t从头开始到j的子字符串的子序列

状态转移公式：

1、当char[i]==char[j]时，则字符i一定是j的子序列，如果0~i-1子字符串是0~j-1子字符串的子序列，则dp[i][j]=true，所以dp[i][j] = dp[i-1][j-1]；
2、当char[i]!=char[j]时，即判断当前0~i子字符串是否是0~j-1的子字符串的子序列，即dp[i][j] = dp[i][j - 1]（这里也就是移动j了，来找i对应的位置的元素和j-1时的位置的元素是否相等）。如ab，eabc，虽然s的最后一个字符和t中最后一个字符不相等，但是因为ab是eab的子序列，所以ab也是eabc的子序列
3、初始化：空字符串一定是t的子字符串的子序列，所以dp[0][j]=true
4、结果：返回dp[sLen][tLen]



        */
        int sLen = s.length(), tLen = t.length();
        if (sLen > tLen) return false;
        if (sLen == 0) return true;
        boolean[][] dp = new boolean[sLen + 1][tLen + 1];
        //初始化
        for (int j = 0; j < tLen; j++) {
            dp[0][j] = true;//空字符串一定是t的子字符串的子序列
        }
        //dp
        for (int i = 1; i <= sLen; i++) {
            for (int j = 1; j <= tLen; j++) {
                if (s.charAt(i - 1) == t.charAt(j - 1)) {
                    dp[i][j] = dp[i - 1][j - 1];//因为s.charAt(i - 1) == t.charAt(j - 1)，所以分别移动i和j的指针，接着判断下一个i和j对应的元素值是否相等
                } else {
                    dp[i][j] = dp[i][j - 1];//这里是s.charAt(i - 1) ！= t.charAt(j - 1)，所以移动j，i先不动，看看目前这个i对应的元素和j的下一个元素j-1的元素 是否相等
                }
            }
        }
        return dp[sLen][tLen];
    }
}

方法二：简单方法（没有用动态规划）：

class Solution {
    public boolean isSubsequence(String s, String t) {
        int i = 0;
        for (char ch : s.toCharArray()) {
            while (i < t.length() && t.charAt(i) != ch) i++;
            i++;
        }
        return i <= t.length() ? true : false;
    }
}

方法三：用到了自带的函数IndexOf：

class Solution {
    public boolean isSubsequence(String s, String t) {
        /*
        java中非常好的一个方法，indexOf(char c,int m)意思是从第m位置开始寻找该索引，找到则返回该索引，否则返回-1，利用该特性我们通过对索引处理从而获得解。
        */
        char[] arr = s.toCharArray();
        int j = -1;
        for(int i = 0;i<arr.length;i++) {
            j = t.indexOf(arr[i],j+1);
            if(j==-1) {
                return false;
            }
        }
        return true;
    }
}