【LeetCode】子数组和子序列的区别

最近在做二刷动态规划中子序列系列问题中发现了一个之前没有注意到的问题，那就是关于子数组和子序列的区别。这两个是不同的要求，处理逻辑也不一样。

二者区别

子数组/子串

从一个数组/字符串中截取一段，这一段在原数组/字符串中也是连续的，如 [2,3 ]是 [1,2,3,4] 的子数组，“qw” 是 “aqwk” 的子串。

子序列

力扣在1143. 最长公共子序列中定义：一个字符串的 子序列是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。如 [1,3] 是 [1,2,3,4] 的子序列，“aw” 是 “aqwkd” 的子序列。

这就导致了我们在做题的时候处理逻辑的不同。

1. 当我们要求子数组时，像718. 最长重复子数组中，在 nums1[i] != nums2[j] 时不进行操作，也就是不把之前的结果传递下去，因为我们要求连续，当nums1[i] != nums2[j]出现时，连续中断，子数组长度归零。
2. 当我们要求子序列时，在nums1[i] != nums2[j]时也要操作，把结果传递下去，dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);，因为子序列不要求连续，所以即使nums1[i] != nums2[j]出现，我们也要累加之前的结果。

这个具体的操作逻辑上的区别还是需要自己动手做题才能体会到。

代码(c++)

1143. 最长公共子序列

关于在遍历推导的时候为什么要从i = 0 , j = 0 开始遍历，因为有些情况dp数组只有一行或一列，从i = 1, j = 1开始就无法获取这种情况的结果。

class Solution {
public:
    int longestCommonSubsequence(string text1, string text2) {
        // 子序列可以不连续，但保证相对顺序
        // dp[i][j]表示text1下表为i结尾，text2下标为j结尾的子串中最长公共子序列的长度。
        int m = text1.size(), n = text2.size();
        vector<vector<int>> dp(m, vector<int>(n, 0));
        // 初始化
        for (int i = 0; i < m; i++) {
            if (text1[i] == text2[0]) dp[i][0] = 1;
            else if (i > 0) dp[i][0] = dp[i - 1][0];
            else dp[i][0] = 0;
        }
        for (int j = 0; j < n; j++) {
            if (text1[0] == text2[j]) dp[0][j] = 1;
            else if (j > 0) dp[0][j] = dp[0][j - 1];
            else dp[0][j] = 0;
        }
        
        int res = 0;
        // 遍历推导
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (i > 0 && j > 0) {
                    if (text1[i] == text2[j]) dp[i][j] = dp[i - 1][j - 1] + 1;
                    else  dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]); // 不等时也要操作，将之前的最大长度传递下去
                } 
                res = max(res, dp[i][j]); // 每次遍历一次都要更新最大长度
            }
        }
        return res;
    }
};

718. 最长重复子数组

class Solution {
public:
    int findLength(vector<int>& nums1, vector<int>& nums2) {
 
        int n = nums1.size(), m = nums2.size(), result = 0;
        vector<vector<int>> dp(n, vector<int>(m, 0));
        // 初始化
        for (int i = 0; i < n; i++) {
            if (nums1[i] == nums2[0]) dp[i][0] = 1;
        }
        for (int j = 0; j < m; j++) {
            if (nums1[0] == nums2[j]) dp[0][j] = 1;
        }
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (nums1[i] == nums2[j] && i > 0 && j > 0) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                } // 不等时不用操作。默认为0
                result = max(result, dp[i][j]);
            }
        }
        return result;
    } 
};