动态规划(8) 编辑距离

目录

• 1035不相交的线
• 53最大子数组和
• 392判断子序列

1035不相交的线

弄清楚在求什么，实际上是在求最长公共子序列

class Solution {
public:
    int maxUncrossedLines(vector<int>& nums1, vector<int>& nums2) {
        int n=nums1.size();
        int m=nums2.size();
        vector<vector<int>> dp(n+1,vector<int>(m+1,0));
        int maxi=0;
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=m;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]);
                }
                maxi=max(maxi,dp[i][j]);
            }
        }
        return maxi;
    }
};

53最大子数组和

比较简单

class Solution {
public:
    //贪心
    int slnA(vector<int>& nums)
    {
        int n=nums.size();
        int ret=INT_MIN;
        int temp=0;
        for(int i=0;i<n;i++)
        {
            temp=temp+nums[i];
            if(temp>ret)
            {
                ret=temp;
            }
            if(temp<0)
            {
                temp=0;
            }
        }
        return ret;
    }
    //动规
    int slnB(vector<int>& nums)
    {
        int n=nums.size();
        vector<int> dp(n,0);
        dp[0]=nums[0];
        int maxi=nums[0];
        for(int i=1;i<n;i++)
        {
            if(dp[i-1]>0)
            {
                dp[i]=dp[i-1]+nums[i];
            }
            else
            {
                dp[i]=nums[i];
            }
            maxi=max(maxi,dp[i]);
        }
        return maxi;
    }
    int maxSubArray(vector<int>& nums) {
        return slnB(nums);

    }
};

392判断子序列

同样是子序列问题，只不过回退方面由于题目的特殊性，不太一样

class Solution {
public:
    bool isSubsequence(string s, string t) {
        int n=s.length();
        int m=t.length();
        vector<vector<int>> dp(n+1,vector<int>(m+1,0));
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=m;j++)
            {
                if(s[i-1]==t[j-1])
                {
                    dp[i][j]=dp[i-1][j-1]+1;
                }
                else
                {
                    //因为我们要求的是s是否为t的子序列
                    //所以s的状态不回退
                    dp[i][j]=dp[i][j-1];
                }
            }
        }
        return dp[n][m]==n;

    }
};