【第53天| ● 1143.最长公共子序列 ● 1035.不相交的线 ● 53. 最大子序和 动态规划 】

1143.最长公共子序列

其实就是0-1背包问题，

• 在遇到元素相等的情况时，容量为j的背包即dp[j]的值应该等于dp[0]~dp[j-1] 范围内的最大值加一（这里的dp[0]至dp[j-1]都是上一层的，因为0-1背包时从后往前遍历的,保证用一个元素不会被多次使用）。
• 而当元素不相等时，dp[j]就应该等于dp[0]-dp[j-1] 范围内的最大值，而这里的dp[0]-dp[j-1]是本层的。简单的理解： 比dp[j]背包容量小的背包可以有k个元素，那我一定是至少可以装的下这k个元素的吧。
  

class Solution {
public:
    int longestCommonSubsequence(string text1, string text2) {
        vector<int>dp(text1.size()+1, 0);
        for(int i=0; i<text2.size(); i++)
        {
            for(int j = text1.size(); j>0; j--){
			//这里要从后往前遍历，因为text2中的字符不能重复的跟text1中的字符匹配，相当于是0-1背包问题
            		if(text2[i]==text1[j-1]){
                    dp[j] = dp[j-1]+1;
                }
            }
            for(int k=1; k<=text1.size(); k++){
            //这里是更新text2[i]!=text1[j-1]时的情况，容量为k的背包dp[k]一定是大于等于容量小于k的dp[k-1];
                if(dp[k]<dp[k-1])   dp[k]=dp[k-1];
            }
        }
        return dp[text1.size()];
    }
};

1035.不相交的线

class Solution {
public:
    int maxUncrossedLines(vector<int>& nums1, vector<int>& nums2) {
        vector<int>dp(nums1.size()+1, 0);
        for(int i=0; i<nums2.size(); i++)
        {
            for(int j = nums1.size(); j>0; j--)//这里要从后往前遍历，因为text2中的字符不能重复的跟text1中的字符比较，相当于是0-1背包问题
            {
                if(nums2[i]==nums1[j-1]){
                    dp[j] = dp[j-1]+1;
                }
            }
            for(int k=1; k<=nums1.size(); k++){//这里是更新text2[i]!=text1[j-1]时的情况，容量为k的背包dp[k]一定是大于等于容量小于k的dp[k-1];
                if(dp[k]<dp[k-1])   dp[k]=dp[k-1];
            }
        }
        return dp[nums1.size()];
    }
};

53. 最大子序和 动态规划

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
         int res = INT32_MIN;
         int sum = 0;
         for(int i=0; i<nums.size(); i++)
         {
             sum += nums[i];
             res = max(res, sum);
             if(sum <0)
             {
                 sum =0;
             }
         }
         return res;
    }
};