2月10日刷题总结

编辑距离

题目描述

设 AA 和 BB 是两个字符串。我们要用最少的字符操作次数，将字符串 AA 转换为字符串 BB。这里所说的字符操作共有三种：

1. 删除一个字符；

2. 插入一个字符；

3. 将一个字符改为另一个字符。

A, BA,B 均只包含小写字母。

输入格式

第一行为字符串 AA；第二行为字符串 BB；字符串 A, BA,B 的长度均小于 20002000。

输出格式

只有一个正整数，为最少字符操作次数。

输入输出样例

输入 #1复制

sfdqxbw

gfdgw

输出 #1复制

4

说明/提示

对于 100 \%100% 的数据，1 \le |A|, |B| \le 20001≤∣A∣,∣B∣≤2000。

思路：第一步确定dp数组的含义：以i-1结尾和j-1结尾的串相同所要操作的最小次数

第二步寻找状态转移方程，寻找状态转移方程的时候我们先要知道删除和增添操作所产生的效果是一样的，例如abcde和abc要变成相同的字符串，我们可以在串一删除，也可以在串二中增添，也可以串一增添，串二删除同时操作，所以我们可以找到:

if(a1[i]==a2[j])dp[i][j]=dp[i-1][j-1]//相等的情况

else //不相等的情况需要进行操作

dp[i][j]=min（dp[i][j-1]+1dp[i-1][j],dp[i-1][j-1]）//分别对应删除串2，删除串1，和替换操作

第三步初始化：dp[0][i]=i,dp[i][0]=i;

code：

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
int min_(int x,int y,int z)
{
    if(y>x)y=x;
    if(z>y)z=y;
    return z;
}
int main()
{
    char s1[2005],s2[2005];
    scanf("%s",s1);
    scanf("%s",s2);
    int dp[2005][2005];
    int n=strlen(s1),m=strlen(s2);
    //初始化
    for(int i=0;i<=n;i++)
    {
        dp[i][0]=i;
    }
    for(int i=0;i<m;i++)
    {
        dp[0][i]=i;
    }
    //dp过程
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            if(s1[i-1]==s2[j-1])dp[i][j]=dp[i-1][j-1];//相等则不用删除和替换操作
            else
            {
                dp[i][j]=min_(dp[i][j-1]+1,dp[i-1][j]+1,dp[i-1][j-1]+1);//不相等的情况删除和替换
            }
        }
    }
    printf("%d",dp[n][m]);
}

最长递增子序列

题目描述

给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。

子序列 是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。

示例 1：

输入：nums = [10,9,2,5,3,7,101,18]

输出：4

解释：最长递增子序列是 [2,3,7,101]，因此长度为 4 。

示例 2：

输入：nums = [0,1,0,3,2,3]

输出：4

示例 3：

输入：nums = [7,7,7,7,7,7,7]

输出：1

提示：

• 1 <= nums.length <= 2500

• -104 <= nums[i] <= 104

思路:

第一步找dp数组的含义：i(包括i)的最小上升子序列；

第二步找状态转移方程：if(nums[i]<nums[j])dp[i]=max(dp[j]+1,dp[i]）;

第三步初始化：因为所有的位置自身也是一个序列。所以dp全部初始化为1;

code:

class Solution 
{
public:
    int lengthOfLIS(vector<int>& nums)
    {
        vector<int> dp(2505,1);//全部初始化为1
        int n=nums.size();
        int ans=0;
        if(n<=1)return n;//特判一下数组长度为1和0
        for(int i=1;i<n;i++)
        {
            for(int j=0;j<i;j++)
            {
                if(nums[i]>nums[j])//此时为递增
                {
                    dp[i]=max(dp[j]+1,dp[i]);
                }
            }
            if(ans<dp[i])ans=dp[i];
        }
        return ans;
    }
};

最长连续递增序列

题目描述

给定一个未经排序的整数数组，找到最长且 连续递增的子序列，并返回该序列的长度。

连续递增的子序列 可以由两个下标 l 和 r（l < r）确定，如果对于每个 l <= i < r，都有 nums[i] < nums[i + 1] ，那么子序列 [nums[l], nums[l + 1], ..., nums[r - 1], nums[r]] 就是连续递增子序列。

示例 1：

输入：nums = [1,3,5,4,7]

输出：3

解释：最长连续递增序列是 [1,3,5], 长度为3。

尽管 [1,3,5,7] 也是升序的子序列, 但它不是连续的，因为 5 和 7 在原数组里被 4 隔开。

示例 2：

输入：nums = [2,2,2,2,2]

输出：1

解释：最长连续递增序列是 [2], 长度为1。

提示：

• 1 <= nums.length <= 104

• -109 <= nums[i] <= 109

思路:

第一步找dp数组的含义：dp数组：i（包括i）之前的字符最大连续序列的个数

第二步找状态转移方程:if(a[i]>a[i-1])dp[i]=dp[i]+1,dp[i-1];

第三步初始化：

code:

class Solution 
{
public:
    int findLengthOfLCIS(vector<int>& nums) 
    {
        int n=nums.size(),ans=0;
        vector<int>dp(n,1);
        if(n<=1)return 1;
        for(int i=1;i<n;i++)
        {
            if(nums[i-1]<nums[i])
            {
                dp[i]=dp[i-1]+1;
            }
            ans=max(ans,dp[i]);
        }
        return ans;
    }
};

最长重复子数组

题目描述

给定两个字符串 text1 和 text2，返回这两个字符串的最长 公共子序列 的长度。如果不存在 公共子序列 ，返回 0 。

一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。

• 例如，"ace" 是 "abcde" 的子序列，但 "aec" 不是 "abcde" 的子序列。

两个字符串的 公共子序列 是这两个字符串所共同拥有的子序列。

示例 1：

输入：text1 = "abcde", text2 = "ace"

输出：3

解释：最长公共子序列是 "ace" ，它的长度为 3 。

示例 2：

输入：text1 = "abc", text2 = "abc"

输出：3

解释：最长公共子序列是 "abc" ，它的长度为 3 。

示例 3：

输入：text1 = "abc", text2 = "def"

输出：0

解释：两个字符串没有公共子序列，返回 0 。

提示：

• 1 <= text1.length, text2.length <= 1000

• text1 和 text2 仅由小写英文字符组成。

思路：

第一步确定dp数组的含义：dp[i][j]:下标i - 1为结尾的A，和以下标j - 1为结尾的B，最长重复⼦数组长度。

第二步找状态转移方程：

if(a1[i]==a2[j])dp[i][j]=dp[i-1][j-1]

else dp[i][j]=dp[i-1][j],dp[i][j-1]

第三步初始化：因为空串不会和另一个串有公共子数组，所以我们初始化为0即可

code:

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

最长公共子序列

题目描述

给定两个字符串 text1 和 text2，返回这两个字符串的最长 公共子序列 的长度。如果不存在 公共子序列 ，返回 0 。

一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。

• 例如，"ace" 是 "abcde" 的子序列，但 "aec" 不是 "abcde" 的子序列。

两个字符串的 公共子序列 是这两个字符串所共同拥有的子序列。

示例 1：

输入：text1 = "abcde", text2 = "ace"

输出：3

解释：最长公共子序列是 "ace" ，它的长度为 3 。

示例 2：

输入：text1 = "abc", text2 = "abc"

输出：3

解释：最长公共子序列是 "abc" ，它的长度为 3 。

示例 3：

输入：text1 = "abc", text2 = "def"

输出：0

解释：两个字符串没有公共子序列，返回 0 。

提示：

• 1 <= text1.length, text2.length <= 1000

• text1 和 text2 仅由小写英文字符组成。

思路：

第一步我们确定dp[i][j]的含义：长度为[0, i - 1]的字符串text1与长度为[0, j - 1]的字符串text2的最长公共⼦序列。

第二步找状态转移方程：

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]);

第三步初始化：同最大子数组一样，全部初始化为0；

code:

class Solution 
{
public:
    int longestCommonSubsequence(string text1, string text2) 
    {
        int dp[1005][1005]={0};
        int n=text1.size();
        int m=text2.size();
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=m;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[n][m];
    }
};