392. 判断子序列

题目描述

双指针

可以使用双指针解法

• 时间复杂度： O ( n ) O(n) O(n)
• 空间复杂度： O ( 1 ) O(1) O(1)

class Solution {
    public boolean isSubsequence(String s, String t) {
        int m = s.length();
        int n = t.length();
        int i = 0; // 双指针
        int j = 0;
        while (i < m && j < n) {
            if (s.charAt(i) == t.charAt(j)) {
                i++;
            }
            j++;
        }
        return i < m ? false : true;
    }
}

dp

my dp code

如果定义 dp[i][j] 表示 s中[0,i] 和 t中[0,j]相同子序列长度，即 dp[m][n] 时，需要单独处理 dp[i][0]、dp[0][j] 较为复杂。

推荐下面 使用 dp[m+1][n+1] ，统一写法

class Solution {
    public boolean isSubsequence(String s, String t) {
        int m = s.length();
        int n = t.length();
        if (m == 0) return true;
        if (n == 0) return false;
        int[][] dp = new int[m][n]; // dp[i][j] 表示 s中[0,i] 和 t中[0,j]相同子序列长度
        // 3、初始化
        for (int i = 0; i < m; i++) dp[i][0] = s.charAt(i) == t.charAt(0) ? 1 : 0;
        for (int j = 1; j < n; j++) dp[0][j] = s.charAt(0) == t.charAt(j) ? 1 : dp[0][j - 1];
        // 4、顺序（从上到下，从左到右）
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                // 2、递推公式
                if (s.charAt(i) == t.charAt(j)) { // 当前字符相等
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                } else { // 当前字符不相等，则需要从 t 中删除当前字符，即需要比较 s[0, i] 和 t[0, j-1] 的相同子序列
                    dp[i][j] = dp[i][j - 1]; // t 删除当前字符
                }
            }
        }
        // 5、打印dp
        for (int i = 0; i < m; i++) {
            System.out.println(Arrays.toString(dp[i]));
        }
        return dp[m - 1][n - 1] == m;
    }
}

carl dp

dp 五步曲：

1. dp[i][j] 表示 s中[0,i-1] 和 t中[0,j-1] 相同子序列长度
   这样初始化能避免单独处理 dp[i][0]、dp[0][j]

   int[][] dp = new int[m + 1][n + 1];
   

2. 递推公式
   • 当前字符相等时，dp[i][j] = dp[i - 1][j - 1] + 1;；
   • 当前字符不相等，则需要从 t 中删除当前字符，即需要比较 s[0, i-1] 和 t[0, j-2] 的相同子序列，即 dp[i][j] = dp[i][j - 1]; // t 删除当前字符
3. 初始化
   定义 dp[m+1][n+1] 不必单独处理 dp[i][0]、dp[0][j]，所有 dp[i][j] 全部初始化为 0，即可
4. 顺序（从上到下，从左到右）

class Solution {
    public boolean isSubsequence(String s, String t) {
        int m = s.length();
        int n = t.length();
        int[][] dp = new int[m + 1][n + 1]; // dp[i][j] 表示 s中[0,i-1] 和 t中[0,j-1]相同子序列长度（这样初始化能避免单独处理 dp[i][0]、dp[0][j]）
        // 3、初始化（使用 dp[m + 1][n + 1] 能避免单独处理 dp[i][0]、dp[0][j]）
        
        // 4、顺序（从上到下，从左到右）
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                // 2、递推公式
                if (s.charAt(i - 1) == t.charAt(j - 1)) { // 当前字符相等
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                } else { // 当前字符不相等，则需要从 t 中删除当前字符，即需要比较 s[0, i-1] 和 t[0, j-2] 的相同子序列
                    dp[i][j] = dp[i][j - 1]; // t 删除当前字符
                }
            }
        }
        // 5、打印dp
        for (int i = 0; i < m; i++) {
            System.out.println(Arrays.toString(dp[i]));
        }
        return dp[m][n] == m;
    }
}

标签：字符,charAt,int,++,392,序列,leetcode,dp
来源： https://blog.csdn.net/weixin_56915683/article/details/120934599