37. 1143.最长公共子序列 ，1035.不相交的线，53. 最大子序和，392.判断子序列

1. 确定dp数组（dp table）以及下标的含义。dp[i][j]：长度为[0, i - 1]的字符串text1与长度为[0, j - 1]的字符串text2的最长公共子序列为dp[i][j]。
2. 确定递推公式。主要就是两大情况： text1[i - 1] 与 text2[j - 1]相同，text1[i - 1] 与 text2[j - 1]不相同。如果text1[i - 1] 与 text2[j - 1]相同，那么找到了一个公共元素，所以dp[i][j] = dp[i - 1][j - 1] + 1；如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的，即：dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])；
3. dp数组如何初始化。
4. 确定遍历顺序。从递推公式，可以看出，有三个方向可以推出dp[i][j]，如图：

class Solution {
public:
    int longestCommonSubsequence(string text1, string text2) {
        int m = text1.size(), n = text2.size();
        // dp[i][j]：长度为[0, i - 1]的字符串text1与长度为[0, j - 1]的字符串text2的最长公共子序列为dp[i][j]
        vector<vector<int>> dp(m + 1, vector<int>(n+1, 0));
        for(int i = 1; i < m + 1; i++){
            for(int j = 1; j < n + 1; j++){
                if(text1[i-1] == text2[j-1]) dp[i][j] = dp[i-1][j-1] + 1;
                else dp[i][j] = max(dp[i][j-1], dp[i-1][j]);
            }
        }
        return dp[m][n];
    }
};

 直线不能相交，这就是说明在字符串A中 找到一个与字符串B相同的子序列，且这个子序列不能改变相对顺序，只要相对顺序不改变，链接相同数字的直线就不会相交。本题说是求绘制的最大连线数，其实就是求两个字符串的最长公共子序列的长度！

class Solution {
public:
    int maxUncrossedLines(vector<int>& nums1, vector<int>& nums2) {
        int n = nums1.size(), m = nums2.size();
        vector<vector<int>> dp(n+1, vector<int>(m+1));

        for(int i = 1; i < n+1; i++){
            for(int j = 1; j < m+1; 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[n][m];

    }
};

class Solution {
public: //贪心思路
    int maxSubArray(vector<int>& nums) {
        int ans = INT32_MIN, sum = 0;

        for(int i = 0; i < nums.size(); i++){

            // 重置最大子序起始位置，因为遇到负数一定是拉低总和
            if(sum < 0) sum = nums[i];
            else sum += nums[i];
            ans = max(ans, sum);
        }
        return ans;
    }
};

class Solution {
public: //动态规划
    int maxSubArray(vector<int>& nums) {
        if(nums.size() == 0) return 0;

        int res = nums[0]; //注意这里是初始化成nums[0]，不是INT32_MIN
        vector<int>dp(nums.size(), 0);
        dp[0] = nums[0]; // 包括下标i（以nums[i]为结尾,一定包含nums[i]）的最大连续子序列和为dp[i]
        for(int i = 1; i < nums.size(); i++){
            dp[i] = max(dp[i - 1] + nums[i], nums[i]);
            res = max(res, dp[i]);
        }
        return res;
    }
};

确定dp数组（dp table）以及下标的含义。dp[i][j] 表示以下标i-1为结尾的字符串s，和以下标j-1为结尾的字符串t，相同子序列的长度为dp[i][j]。

确定递推公式。在确定递推公式的时候，首先要考虑如下两种操作，整理如下：if (s[i - 1] == t[j - 1])，t中找到了一个字符在s中也出现了。if (s[i - 1] != t[j - 1])，相当于t要删除元素，继续匹配。

if (s[i - 1] == t[j - 1])，那么dp[i][j] = dp[i - 1][j - 1] + 1;，因为找到了一个相同的字符，相同子序列长度自然要在dp[i-1][j-1]的基础上加1。

if (s[i - 1] != t[j - 1])，此时相当于t要删除元素，t如果把当前元素t[j - 1]删除，那么dp[i][j] 的数值就是 看s[i - 1]与 t[j - 2]的比较结果了，即：dp[i][j] = dp[i][j - 1]。

 dp数组如何初始化。从递推公式可以看出dp[i][j]都是依赖于dp[i - 1][j - 1] 和 dp[i][j - 1]，所以dp[0][0]和dp[i][0]是一定要初始化的。

确定遍历顺序。同理从递推公式可以看出dp[i][j]都是依赖于dp[i - 1][j - 1] 和 dp[i][j - 1]，那么遍历顺序也应该是从上到下，从左到右。

class Solution {
public: //贪心思路
    bool isSubsequence(string s, string t) {
        int t1 = 0;
        int s1 = 0;
        while(t1 < t.size() && s1 < s.size() ){
            if (t[t1] == s[s1]) s1++;
                 t1++;
        }
        if(s1 ==  s.size()) return true;
        else return false;
    }
};

class Solution {
public: //动态规划，编辑距离
    bool isSubsequence(string s, string t) {

        // 注意理解下初始化size为什么要加 1
        vector<vector<int>> dp(s.size() + 1, vector<int>(t.size() + 1, 0));

        for(int i = 1; i < s.size() + 1; i++){ //注意理解一下遍历顺序
            for(int j = 1; j < t.size() + 1; 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 s.size() == dp[s.size()][t.size()];
    }
};

 这道题目算是编辑距离的入门题目（毕竟这里只是涉及到减法），也是动态规划解决的经典题型。注意本题和 1143.最长公共子序列 的区别。