算法学习 | day46/60 最长公共子序列/不相交的线/最大子序和

一、题目打卡

        1.1 最长公共子序列

        题目链接：. - 力扣（LeetCode）

class Solution {
public:
    int longestCommonSubsequence(string text1, string text2) {
        vector<vector<int>> dp(text1.size(), vector<int>(text2.size(), 0));

        for(int i = 0 ; i < text1.size(); i++){
            // if(text1[i] == text2[0]) dp[i][0] = 1;
            if(text1[i] == text2[0]){
                while(i < text1.size()){
                    dp[i][0] = 1;
                    i++;
                }
            }
        }

        for(int i = 0 ; i < text2.size(); i++){
            // if(text2[i] == text1[0]) dp[0][i] = 1;
            if(text2[i] == text1[0]){
                while(i < text2.size()){
                    dp[0][i] = 1;
                    i++;
                }
            }
        }

        // for(int i = 0 ; i < text1.size();i++){
        //     for(int j = 0 ;j < text2.size();j++){
        //         cout << dp[i][j];
        //     }
        //     cout << endl;
        // }
        // cout << "---------------" << endl;

        for(int i = 1 ; i < text1.size();i++){
            for(int j = 1 ; j < text2.size();j++){
                if(text1[i] == text2[j]) dp[i][j] = dp[i - 1][j - 1] + 1;
                else dp[i][j] = max(dp[i][j - 1], dp[i - 1][j]);
            }
        }
        // for(int i = 0 ; i < text1.size();i++){
        //     for(int j = 0 ;j < text2.size();j++){
        //         cout << dp[i][j];
        //     }
        //     cout << endl;
        // }
        return dp[text1.size() - 1][text2.size() - 1];
    }
};

        做这个题目的时候，我想到了之前做的最大递增子序列那个题目，这样来看的前提下，这个题目就会形成一个四层循环（因为最后两层需要去找到前面dp数组数值最大的位置），但是我看了一眼答案发现并没有这样，于是引起了思考，思考的结果是，由于这个题目存在两个方面的区别，首先是递增子序列那个题目，需要去检索的是在前面的序列中，比当前值要小的组合，但是这个题目不存在找这个，并且我发现这个题目搜索的过程中是一个二维的数组，也就是是两个数组之间的对比，和之前那个一维数组不太一样，这样的情况下，状态转移就可以来自上面，左边和左上角，也就是这个存在继承的关系，但是之前的递增子序列不存在，因为本身数组是无序的，继承之前的数的前提是必须当前值要比前面的值都要大，但是这个是数组的比较，只存在相等与否，所以不存在这个问题。

        然后做的过程中发现一个问题就是，这个题目的初始化也有一定的考究，考虑到我上面说的那个继承的情况，所以初始化的方式和之前不一样，这样的情况下，如果为了简化这个初始化的过程，其实可以给dp数组增加一个维度：

class Solution {
public:
    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()];
    }
};

        1.2 不想交的线

        题目链接：. - 力扣（LeetCode）

class Solution {
public:
    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() + 1; i++){
            for(int j = 1 ; j < nums2.size() + 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]);
            }
        }
        // for(int i = 0 ; i < nums1.size() + 1;i++){
        //     for(int j = 0 ; j < nums2.size() + 1; j++){
        //         cout << dp[i][j] << " ";
        //     }
        //     cout << endl;
        // }
        return dp[nums1.size()][nums2.size()];
    }
};

        这个题目和上面的那个题目是一样的，也就算是上面那个题目的一个实际的使用的描述形式。写的时候需要注意，如果是这种不需要初始化的情况，那么在进行nums1和nums2的比较的时候，就需要对索引进行减 1 的操作。

        1.3 最大子数组和

        题目链接：. - 力扣（LeetCode）

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        vector<int> dp(nums.size(), 0);
        dp[0] = nums[0];
        int res = dp[0];

        for(int i = 1 ; i < nums.size();i++){
            // if(nums[i] > nums[i - 1]) dp[i] = dp[i - 1] + nums[i];
            // else dp[i] = nums[i];
            // if(dp[i - 1] + nums[i] > dp[i - 1]) dp[i] = max(dp[i - 1] + nums[i], nums[i]);
            // if(nums[i] + dp[i - 1] > 0) dp[i] = max(dp[i - 1] + nums[i], nums[i]); // 如果前面积累的还没有当前的数字大，那就直接以当前的值作为初值
            if( dp[i - 1] > 0) dp[i] = dp[i - 1] + nums[i]; // 如果前面积累的还没有当前的数字大，那就直接以当前的值作为初值
            else dp[i] = nums[i];
            res = max(dp[i], res);
        }
        // for(auto & it : dp){
        //     cout << it << " ";
        // }
        // cout << endl;
        return res;
    }
};

        这个主要思路是理解清楚状态的定义，从 0 到 i 的所得到的连续子数组的最大和，这样的就可以看出，状态转移就会分为两个情况，如果之前的状态是正数，那么这一轮就可以继续进行累加，如果是dp数组的状态是负数了，那么就重置然后重新开始累加。

        或者是按照这种理解也是可以的：

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        if (nums.size() == 0) return 0;
        vector<int> dp(nums.size());
        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]; // result 保存dp[i]的最大值
        }
        return result;
    }
};

        这样道理其实是一样的，这样比大，其实是为了排除掉dp数组的前一项为负数的情况，因为这样继续累加肯定会导致数值变小。