【数组子序列类型动态规划】

链接：300. 最长递增子序列 - 力扣（LeetCode）

题目描述：

解题思路：

1. 数组中的元素可以是不连续的；
2. dp[i] 表示以nums[i]为结尾的最大递增子序列；
3. 因为是不连续的，需要依次看前i-1个元素的最大值是多少；
4. 需要在这个过程中保存最大的值；

    int lengthOfLIS(vector<int>& nums) {
        int result = 1;
        vector<int> dp(nums.size(), 1);
        for (int i = 1; i < nums.size(); i++) {
            for (int j = 0; j < i; j++) {
                if (nums[i] > nums[j]) dp[i] = max(dp[i], dp[j]+1);
                if (dp[i] > result) result = dp[i];
            }
        }
        return result;
    }

链接：674. 最长连续递增序列 - 力扣（LeetCode）

题目描述：

解题思路：

1. 和上一个题的区别在于是连续的，在判断的时候只需要遍历一次就可以了；
2. 可以优化内存空间，相当于更新了连续增长序列的起始位置；

    int findLengthOfLCIS(vector<int>& nums) {
        // int result = 1;
        // vector<int> dp(nums.size(), 1);
        // for (int i = 1; i < nums.size(); i++) {
        //     if (nums[i] > nums[i-1]) dp[i] = dp[i-1] + 1;
        //     if (dp[i] > result) result = dp[i];
        // }
        // return result;
        int result = 1, count = 1;
        for (int i = 1; i < nums.size(); i++) {
            if (nums[i] > nums[i-1]) count++;
            else count = 1;
            if (count > result) result = count;
        }
        return result;
    }

链接：718. 最长重复子数组 - 力扣（LeetCode）

解题思路：

1. 两个数组对比，可以通过画图的方式帮助理解；
2. 由于是连续的，对于前缀数组，单看它们的末尾项，如果它们俩不一样，则公共子数组肯定不包括它们俩，所以不用操作；
3. 在过程中记录最长的长度；

    int findLength(vector<int>& nums1, vector<int>& nums2) {
        int result = 0;
        vector<vector<int>> dp(nums1.size()+1, vector<int>(nums2.size()+1, 0));
        for (int i = 1; i <= nums1.size(); i++) {
            for (int j = 1; j <= nums2.size(); j++) {
                if (nums1[i-1] == nums2[j-1]) dp[i][j] = dp[i-1][j-1] + 1;
                if (dp[i][j] > result) result = dp[i][j];
            }   
        }
        return result;
    }

链接：1143. 最长公共子序列 - 力扣（LeetCode）

解题思路：

1. 由于可以删除元素，所以可以不连续；

    int longestCommonSubsequence(string text1, string text2) {
        vector<vector<int>> dp(text1.size() + 1, vector<int>(text2.size() + 1, 0));
        for (int i = 1; i <= text1.size(); i++) {
            for (int j = 1; j <= text2.size(); j++) {
                if (text1[i-1] == text2[j-1]) dp[i][j] = dp[i-1][j-1] + 1;
                else dp[i][j] = max(dp[i-1][j], dp[i][j-1]);
            }
        }
        return dp[text1.size()][text2.size()];
    }

链接：1035. 不相交的线 - 力扣（LeetCode）

题目描述：

解题思路：

1. 直线不能相交，公共子序列不能改变相对顺序；
2. 最大连线数，就是最长公共子序列，可以是不连续的。

    int maxUncrossedLines(vector<int>& nums1, vector<int>& nums2) {
        vector<vector<int>> dp(nums1.size() + 1, vector<int>(nums2.size() + 1, 0));
        for (int i = 1; i <= nums1.size(); i++) {
            for (int j = 1; j <= nums2.size(); j++) {
                if (nums1[i-1] == nums2[j-1]) dp[i][j] = dp[i-1][j-1] + 1;
                else dp[i][j] = max(dp[i-1][j], dp[i][j-1]);
            }
        }
        return dp[nums1.size()][nums2.size()];
    }

链接：53. 最大子数组和 - 力扣（LeetCode）

解题思路：

1. 和最长递增子数组的区别在于条件的判断；
2. 贪心的思路，每次count <= 0的时候，重置起始位置；

    int maxSubArray(vector<int>& nums) {
        vector<int> dp(nums.size(), 0);
        dp[0] = nums[0];
        int result = dp[0];
        for (int i = 1; i < nums.size(); i++) {
            dp[i] = max(dp[i-1] + nums[i], nums[i]);
            if (dp[i] > result) result = dp[i];
        }
        return result;
    }

    int maxSubArray(vector<int>& nums) {
        int result = INT32_MIN;
        int count = 0;
        for (int i = 0; i < nums.size(); i++) {
            count += nums[i];
            if (count > result) { // 取区间累计的最大值（相当于不断确定最大子序终止位置）
                result = count;
            }
            if (count <= 0) count = 0; // 相当于重置最大子序起始位置，因为遇到负数一定是拉低总和
        }
        return result;
    }

链接：152. 乘积最大子数组 - 力扣（LeetCode）

解题思路：

1. 基本条件是 imax = max(imax*nums[i], nums[i]);
2. 由于存在负数，负数会让最大值变成最小值，所以每次遇到负数，交换最大值和最小值，能够让乘积更大；
3. 同时需要维护一个最小值；

    int maxProduct(vector<int>& nums) {
        int result = INT_MIN, imax= 1, imin = 1;
        for (int i = 0; i < nums.size(); i++) {
            if (nums[i] < 0) swap(imax, imin);
            imax = max(imax*nums[i], nums[i]);
            imin = min(imin*nums[i], nums[i]);
            result = max(result, imax);
        }
        return result;
    }

链接：392. 判断子序列 - 力扣（LeetCode）

解题思路：

1. 题目类似查找最长公共子序列；
2. dp[i][j] 表示以下标i-1为结尾的字符串s，和以下标j-1为结尾的字符串t，相同子序列的长度为dp[i][j]
3. 由于t可以删除，所以在不相等的时候当前长度和j-2的相同子序列的长度相同；

    bool isSubsequence(string s, string t) {
        vector<vector<int>> dp(s.size() + 1, vector<int>(t.size() + 1, 0));
        for (int i = 1; i <= s.size(); i++) {
            for (int j = 1; j <= t.size(); j++) {
                if (s[i-1] == t[j-1]) dp[i][j] = dp[i-1][j-1] + 1;
                else dp[i][j] = dp[i][j-1];
            }
        }
        return dp[s.size()][t.size()] == s.size();
    }

链接：115. 不同的子序列 - 力扣（LeetCode）

    int numDistinct(string s, string t) {
        vector<vector<uint64_t>> dp(s.size() + 1, vector<uint64_t>(t.size() + 1, 0));
        for (int i = 0; i <= s.size(); i++) dp[i][0] = 1;
        for (int i = 1; i <= s.size(); i++) {
            for (int j = 1; j <= t.size(); j++) {
                if (s[i-1] == t[j-1]) dp[i][j] = dp[i-1][j-1] + dp[i-1][j];
                else dp[i][j] = dp[i-1][j];
            }
        }
        return dp[s.size()][t.size()];
    }

链接：583. 两个字符串的删除操作 - 力扣（LeetCode）

    int minDistance(string word1, string word2) {
        vector<vector<int>> dp(word1.size() + 1, vector<int>(word2.size() + 1, 0));
        for (int i = 1; i <= word2.size(); i++) dp[0][i] = dp[0][i-1] + 1;
        for (int i = 1; i <= word1.size(); i++) dp[i][0] = dp[i-1][0] + 1;
        for (int i = 1; i <= word1.size(); i++) {
            for (int j = 1; j <= word2.size(); j++) {
                if (word1[i-1] == word2[j-1]) dp[i][j] = dp[i-1][j-1];
                else dp[i][j] = min(dp[i-1][j], dp[i][j-1]) + 1;
            }
        }
        return dp[word1.size()][word2.size()];
    }

链接：72. 编辑距离 - 力扣（LeetCode）

参考题解：72. 编辑距离 - 力扣（LeetCode）

    int minDistance(string word1, string word2) {
        vector<vector<int>> dp(word1.size() + 1, vector<int>(word2.size() + 1, 0));
        for (int i = 1; i <= word2.size(); i++) dp[0][i] = dp[0][i-1] + 1;
        for (int i = 1; i <= word1.size(); i++) dp[i][0] = dp[i-1][0] + 1;
        for (int i = 1; i <= word1.size(); i++) {
            for (int j = 1; j <= word2.size(); j++) {
                if (word1[i-1] == word2[j-1]) dp[i][j] = dp[i-1][j-1];
                else dp[i][j] = min(dp[i-1][j-1], min(dp[i-1][j], dp[i][j-1])) + 1;
            }
        }
        return dp[word1.size()][word2.size()];
    }