【C++代码】编辑距离，最长递增子序列，最长连续递增序列，最长重复子数组，最长公共子序列，不相交的线，动态规划--代码随想录

企业开发 2023-12-17 00:44:51 阅读次数: 0

题目：最长递增子序列

  • 给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。子序列 是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。

  • dp[i]的定义：dp[i]表示i之前包括i的以nums[i]结尾的最长递增子序列的长度

  • 状态转移方程：位置i的最长升序子序列等于j从0到i-1各个位置的最长升序子序列 + 1 的最大值。所以：if (nums[i] > nums[j]) dp[i] = max(dp[i], dp[j] + 1);

  • dp[i]的初始化：每一个i，对应的dp[i]（即最长递增子序列）起始大小至少都是1.

  • 在这里插入图片描述

  • class Solution {
      
      
public:
    int lengthOfLIS(vector<int>& nums) {
      
      
        if(nums.size()<2){
      
      
            return nums.size();
        }
        vector<int> dp(nums.size(),1);
        int res=0;
        for(int i=1;i<nums.size();i++){
      
      
            for(int j=0;j<i;j++){
      
      
                if(nums[i]>nums[j]){
      
      
                    dp[i]=max(dp[i],dp[j]+1);
                }
            }
            if(res<dp[i]){
      
      
                res=dp[i];
            }
        }
        return res;
    }
};

  • 时间复杂度: O(n^2)；空间复杂度: O(n)

题目：最长连续递增序列

  • 给定一个未经排序的整数数组，找到最长且 连续递增的子序列，并返回该序列的长度。连续递增的子序列 可以由两个下标 l 和 r（l < r）确定，如果对于每个 l <= i < r，都有 nums[i] < nums[i + 1] ，那么子序列 [nums[l], nums[l + 1], ..., nums[r - 1], nums[r]] 就是连续递增子序列。

  • 确定dp数组（dp table）以及下标的含义：dp[i]：以下标i为结尾的连续递增的子序列长度为dp[i]。

  • 确定递推公式：如果 nums[i] > nums[i - 1]，那么以 i 为结尾的连续递增的子序列长度 一定等于 以i - 1为结尾的连续递增的子序列长度 + 1 。即：dp[i] = dp[i - 1] + 1;因为本题要求连续递增子序列，所以就只要比较nums[i]与nums[i - 1]，而不用去比较nums[j]与nums[i] （j是在0到i之间遍历）。

  • dp数组如何初始化：以下标i为结尾的连续递增的子序列长度最少也应该是1，即就是nums[i]这一个元素。

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

  • 也可以用贪心来做，也就是遇到nums[i] > nums[i - 1]的情况，count就++，否则count为1，记录count的最大值就可以了。

  • class Solution {
      
      
public:
    int findLengthOfLCIS(vector<int>& nums) {
      
      
        if(nums.size()<2){
      
      
            return nums.size();
        }
        int count=1;
        int res=0;
        for(int i=0;i<nums.size()-1;i++){
      
      
            if(nums[i]<nums[i+1]){
      
      
                count++;
            }else{
      
      
                count=1;
            }
            // res = res>count?res:count;
            if(count>res){
      
      
                res=count;
            }
        }
        return res;
    }
};

  • 时间复杂度：O(n)；空间复杂度：O(1)

题目：最长重复子数组

  • 给两个整数数组 nums1 和 nums2 ，返回 两个数组中 公共的 、长度最长的子数组的长度 。

  • 用二维数组可以记录两个字符串的所有比较情况，这样就比较好推 递推公式了。 动规五部曲分析如下：

    • 确定dp数组（dp table）以及下标的含义：dp[i][j] ：以下标i - 1为结尾的A，和以下标j - 1为结尾的B，最长重复子数组长度为dp[i] [j]。 （特别注意： “以下标i - 1为结尾的A” 标明一定是 以A[i-1]为结尾的字符串 ）
    • 确定递推公式：根据dp[i][j]的定义，dp[i] [j]的状态只能由dp[i - 1] [j - 1]推导出来。即当A[i - 1] 和B[j - 1]相等的时候，dp[i] [j] = dp[i - 1] [j - 1] + 1;
    • dp数组如何初始化：为了方便递归公式dp[i] [j] = dp[i - 1] [j - 1] + 1;所以dp[i] [0] 和dp[0] [j]初始化为0。
    • 确定遍历顺序：外层for循环遍历A，内层for循环遍历B。
    • 在这里插入图片描述
  • class Solution {
      
      
public:
    int findLength(vector<int>& nums1, vector<int>& nums2) {
      
      
        vector<vector<int>> dp(nums1.size()+1,vector<int>(nums2.size()+1,0));
        int res=0;
        for(int i=1;i<=nums1.size();i++){
      
      
            for(int j=1;j<=nums2.size();j++){
      
      
                if(nums1[i-1]==nums2[j-1]){
      
      
                    dp[i][j] = dp[i-1][j-1]+1;
                }
                if(dp[i][j]>res){
      
      
                    res=dp[i][j];
                }
            }
        }
        return res;
    }
};

  • 时间复杂度：O(n × m)，n 为A长度，m为B长度；空间复杂度：O(n × m)

题目：最长公共子序列

  • 给定两个字符串 text1 和 text2，返回这两个字符串的最长 公共子序列 的长度。如果不存在 公共子序列 ，返回 0 。一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。两个字符串的 公共子序列 是这两个字符串所共同拥有的子序列。

  • 确定dp数组（dp table）以及下标的含义：dp[i] [j]：长度为[0, i - 1]的字符串text1与长度为[0, j - 1]的字符串text2的最长公共子序列为dp[i] [j]。

  • 确定递推公式：主要就是两大情况： 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数组如何初始化：test1[0, i-1]和空串的最长公共子序列自然是0，所以dp[i] [0] = 0;同理dp[0] [j]也是0。其他下标都是随着递推公式逐步覆盖，初始为多少都可以，那么就统一初始为0。
    • 在这里插入图片描述
  • 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()];
    }
};

  • 时间复杂度: O(n * m)，其中 n 和 m 分别为 text1 和 text2 的长度；空间复杂度: O(n * m)

题目：不相交的线

  • 在两条独立的水平线上按给定的顺序写下 nums1 和 nums2 中的整数。现在，可以绘制一些连接两个数字 nums1[i] 和 nums2[j] 的直线，这些直线需要同时满足满足：nums1[i] == nums2[j]。且绘制的直线不与任何其他连线（非水平线）相交。请注意，连线即使在端点也不能相交：每个数字只能属于一条连线。以这种方法绘制线条，并返回可以绘制的最大连线数。

  • **本题说是求绘制的最大连线数，其实就是求两个字符串的最长公共子序列的长度！**这就和上一题的思路一样了。

  • 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();i++){
      
      
            for(int j=1;j<=nums2.size();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[nums1.size()][nums2.size()];
    }
};

题目：最大子数组和

  • 给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

  • 确定dp数组（dp table）以及下标的含义：dp[i]：包括下标i（以nums[i]为结尾）的最大连续子序列和为dp[i]。

  • 确定递推公式：dp[i]只有两个方向可以推出来

    • dp[i - 1] + nums[i]，即：nums[i]加入当前连续子序列和
    • nums[i]，即：从头开始计算当前连续子序列和。一定是取最大的，所以dp[i] = max(dp[i - 1] + nums[i], nums[i]);
    • dp数组如何初始化：从递推公式可以看出来dp[i]是依赖于dp[i - 1]的状态，dp[0]就是递推公式的基础。根据dp[i]的定义，很明显dp[0]应为nums[0]即dp[0] = nums[0]。
  • class Solution {
      
      
public:
    int maxSubArray(vector<int>& nums) {
      
      
        if(nums.size()==0){
      
      
            return 0;
        }
        int res=nums[0];
        vector<int> dp(nums.size(),0);
        dp[0] = nums[0];
        for(int i=1;i<nums.size();i++){
      
      
            dp[i] = max(dp[i-1]+nums[i],nums[i]);
            if(dp[i]>res){
      
      
                res=dp[i];
            }
        }
        return res;
    }
};

题目：判断子序列

  • 给定字符串 s 和 t ，判断 s 是否为 t 的子序列。字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。

  • 自己编的过了16个用例，就是通过不了完整的

    • class Solution {
        
        
public:
    bool isSubsequence(string s, string t) {
        
        
        int s_len=s.size(),t_len=t.size();
        if(s_len>t_len){
        
        
            return false;
        }
        int temp_index=0;
        for(int i=0;i<s_len;i++){
        
        
            while(s[i]!=t[temp_index] && temp_index<t_len){
        
        
                temp_index++;
            }
            if(t_len-temp_index < s_len-i){
        
        
                return false;
            }
        }
        return true;
    }
};

  • 动态规划五部曲分析如下：

    • 确定dp数组（dp table）以及下标的含义：dp[i] [j] 表示以下标i-1为结尾的字符串s，和以下标j-1为结尾的字符串t，相同子序列的长度为dp[i] [j]。注意这里是判断s是否为t的子序列。即t的长度是大于等于s的。
    • 确定递推公式：在确定递推公式的时候，首先要考虑如下两种操作，整理如下：
      • if (s[i - 1] == t[j - 1]) ； t中找到了一个字符在s中也出现了
      • if (s[i - 1] != t[j - 1]) ； 相当于t要删除元素，继续匹配
    • dp数组如何初始化：从递推公式可以看出dp[i] [j]都是依赖于dp[i - 1] [j - 1] 和 dp[i] [j - 1]，所以dp[0] [0]和dp[i] [0]是一定要初始化的。这里大家已经可以发现，在定义dp[i][j]含义的时候为什么要表示以下标i-1为结尾的字符串s，和以下标j-1为结尾的字符串t，相同子序列的长度为dp[i] [j]。
    • 在这里插入图片描述
  • class Solution {
      
      
public:
    bool isSubsequence(string s, string t) {
      
      
        vector<vector<int>> dp(s.size()+1,vector<int>(t.size()+1,0));
        for(int i=1;i<=s.size();i++){
      
      
            for(int j=1;j<=t.size();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 dp[s.size()][t.size()]==s.size();
    }
};

  • 时间复杂度：O(n × m)；空间复杂度：O(n × m)

  • 在这里插入图片描述

题目：不同的子序列

  • 给你两个字符串 s 和 t ，统计并返回在 s 的 子序列 中 t 出现的个数，结果需要对 10^9 + 7 取模。

  • 这道题目如果不是子序列，而是要求连续序列的，那就可以考虑用KMP。

  • 确定dp数组（dp table）以及下标的含义:dp[i] [j]：以i-1为结尾的s子序列中出现以j-1为结尾的t的个数为dp[i] [j]。

  • 确定递推公式:这一类问题，基本是要分析两种情况；s[i - 1] 与 t[j - 1]相等；s[i - 1] 与 t[j - 1] 不相等。当s[i - 1] 与 t[j - 1]相等时，dp[i] [j]可以有两部分组成。一部分是用s[i - 1]来匹配，那么个数为dp[i - 1] [j - 1]。即不需要考虑当前s子串和t子串的最后一位字母，所以只需要 dp[i-1] [j-1]。一部分是不用s[i - 1]来匹配，个数为dp[i - 1] [j]。当s[i - 1] 与 t[j - 1]不相等时，dp[i] [j]只有一部分组成，不用s[i - 1]来匹配（就是模拟在s中删除这个元素），即：dp[i - 1] [j]

  • dp数组如何初始化：从递推公式dp[i] [j] = dp[i - 1] [j - 1] + dp[i - 1] [j]; 和 dp[i] [j] = dp[i - 1] [j]; 中可以看出dp[i] [j] 是从上方和左上方推导而来，那么 dp[i] [0] 和dp[0] [j]是一定要初始化的。dp[i] [0] 表示：以i-1为结尾的s可以随便删除元素，出现空字符串的个数。那么dp[i] [0]一定都是1，因为也就是把以i-1为结尾的s，删除所有元素，出现空字符串的个数就是1。

  • class Solution {
      
      
public:
    int numDistinct(string s, string t) {
      
      
        vector<vector<uint64_t>> dp(s.size()+1,vector<uint64_t>(t.size()+1));
        for(int i=0;i<s.size();i++){
      
      
            dp[i][0] = 1;
        }
        for(int i=1;i<=s.size();i++){
      
      
            for(int j=1;j<=t.size();j++){
      
      
                if(s[i-1]==t[j-1]){
      
      
                    dp[i][j] = dp[i-1][j-1] + dp[i-1][j];
                }else{
      
      
                    dp[i][j] = dp[i-1][j];
                }
            }
        }
        return dp[s.size()][t.size()];
    }
};

  • 时间复杂度: O(n * m)； 空间复杂度: O(n * m)

  • 在这里插入图片描述

  • 从递推公式dp[i] [j] = dp[i - 1] [j - 1] + dp[i - 1] [j]; 和 dp[i] [j] = dp[i - 1] [j]; 中可以看出dp[i] [j]都是根据左上方和正上方推出来的。

题目：两个字符串的删除操作

  • 给定两个单词 word1 和 word2 ，返回使得 word1 和 word2 相同所需的最小步数。每步 可以删除任意一个字符串中的一个字符。

  • 这次是两个字符串可以相互删了，这种题目也知道用动态规划的思路来解，动规五部曲，分析如下：

    • 确定dp数组（dp table）以及下标的含义：dp[i] [j]：以i-1为结尾的字符串word1，和以j-1位结尾的字符串word2，想要达到相等，所需要删除元素的最少次数。
    • 确定递推公式：当word1[i - 1] 与 word2[j - 1]相同的时候；当word1[i - 1] 与 word2[j - 1]不相同的时候
      • 当word1[i - 1] 与 word2[j - 1]相同的时候，dp[i] [j] = dp[i - 1] [j - 1];
      • 当word1[i - 1] 与 word2[j - 1]不相同的时候，有三种情况：
        • 情况一：删word1[i - 1]，最少操作次数为dp[i - 1] [j] + 1
        • 情况二：删word2[j - 1]，最少操作次数为dp[i] [ j - 1] + 1
        • 情况三：同时删word1[i - 1]和word2[j - 1]，操作的最少次数为dp[i - 1] [j - 1] + 2
    • 那最后当然是取最小值，所以当word1[i - 1] 与 word2[j - 1]不相同的时候，递推公式：dp[i][j] = min({dp[i - 1] [j - 1] + 2, dp[i - 1] [j] + 1, dp[i] [j - 1] + 1});
    • dp数组如何初始化：dp[i] [0]：word2为空字符串，以i-1为结尾的字符串word1要删除多少个元素，才能和word2相同呢，很明显dp[i] [0] = i。dp[0] [j]的话同理
    • 确定遍历顺序：从递推公式 dp[i] [j] = min(dp[i - 1] [j - 1] + 2, min(dp[i - 1] [j], dp[i] [j - 1]) + 1); 和dp[i] [j] = dp[i - 1] [j - 1]可以看出dp[i] [j]都是根据左上方、正上方、正左方推出来的。
  • class Solution {
      
      
public:
    int minDistance(string word1, string word2) {
      
      
        vector<vector<int>> dp(word1.size()+1,vector<int>(word2.size()+1));
        for(int i=0;i<=word1.size();i++){
      
      
            dp[i][0]=i;
        }
        for(int i=0;i<=word2.size();i++){
      
      
            dp[0][i]=i;
        }
        for(int i=1;i<=word1.size();i++){
      
      
            for(int j=1;j<=word2.size();j++){
      
      
                if(word1[i-1]==word2[j-1]){
      
      
                    dp[i][j] = dp[i-1][j-1];
                }else{
      
      
                    dp[i][j] = min(dp[i-1][j]+1,dp[i][j-1]+1);
                }
            }
        }
        return dp[word1.size()][word2.size()];
    }
};

题目：编辑距离

  • 给你两个单词 word1 和 word2， 请返回将 word1 转换成 word2 所使用的最少操作数 。你可以对一个单词进行如下三种操作：插入一个字符; 删除一个字符; 替换一个字符。

  • 确定dp数组（dp table）以及下标的含义：dp[i] [j] 表示以下标i-1为结尾的字符串word1，和以下标j-1为结尾的字符串word2，最近编辑距离为dp[i] [j]。

  • 确定递推公式：if (word1[i - 1] == word2[j - 1]) 那么说明不用任何编辑，dp[i] [j] 就应该是 dp[i - 1] [j - 1]，即dp[i] [j] = dp[i - 1] [j - 1];

    • if (word1[i - 1] != word2[j - 1])，此时就需要编辑了，如何编辑呢？操作一：word1删除一个元素，那么就是以下标i - 2为结尾的word1 与 j-1为结尾的word2的最近编辑距离 再加上一个操作。即 dp[i][j] = dp[i - 1][j] + 1;
    • 操作二：word2删除一个元素，那么就是以下标i - 1为结尾的word1 与 j-2为结尾的word2的最近编辑距离 再加上一个操作。dp[i][j] = dp[i][j - 1] + 1;word2添加一个元素，相当于word1删除一个元素，例如 word1 = "ad" ，word2 = "a"，word1删除元素'd' 和 word2添加一个元素'd'，变成word1="a", word2="ad"， 最终的操作数是一样！
    • 操作三：替换元素，word1替换word1[i - 1]，使其与word2[j - 1]相同，此时不用增删加元素。if (word1[i - 1] == word2[j - 1])的时候我们的操作 是 dp[i][j] = dp[i - 1][j - 1] 对吧。所以 dp[i][j] = dp[i - 1][j - 1] + 1;
    • 综上，当 if (word1[i - 1] != word2[j - 1]) 时取最小的，即：dp[i][j] = min(dp[i - 1][j - 1], dp[i - 1][j], dp[i][j - 1]) + 1;

  • dp数组如何初始化:dp[i] [j] 表示以下标i-1为结尾的字符串word1，和以下标j-1为结尾的字符串word2，最近编辑距离为dp[i] [j]。dp[i] [0] ：以下标i-1为结尾的字符串word1，和空字符串word2，最近编辑距离为dp[i] [0]。那么dp[i] [0]就应该是i，对word1里的元素全部做删除操作，即：dp[i] [0] = i;

  • 在这里插入图片描述

  • class Solution {
      
      
public:
    int minDistance(string word1, string word2) {
      
      
        vector<vector<int>> dp(word1.size()+1,vector<int>(word2.size()+1));
        for(int i=1;i<=word1.size();i++){
      
      
            dp[i][0] = i;
        }
        for(int j=0;j<=word2.size();j++){
      
      
            dp[0][j] = j;
        }
        for(int i=1;i<=word1.size();i++){
      
      
            for(int j=1;j<=word2.size();j++){
      
      
                if(word1[i-1] == word2[j-1]){
      
      
                    dp[i][j] = dp[i-1][j-1];
                }else{
      
      
                    dp[i][j] = min(dp[i-1][j-1],min(dp[i-1][j],dp[i][j-1]))+1;
                }
            }
        }
        return dp[word1.size()][word2.size()];
    }
};

  • 时间复杂度: O(n * m)； 空间复杂度: O(n * m)

题目：回文子串

  • 给你一个字符串 s ，请你统计并返回这个字符串中 回文子串 的数目。回文字符串 是正着读和倒过来读一样的字符串。子字符串 是字符串中的由连续字符组成的一个序列。具有不同开始位置或结束位置的子串，即使是由相同的字符组成，也会被视作不同的子串。

  • 暴力解法：两层for循环，遍历区间起始位置和终止位置，然后还需要一层遍历判断这个区间是不是回文。所以时间复杂度：O(n^3)

  • 动态规划：确定dp数组（dp table）以及下标的含义，dp数组是要定义成一位二维dp数组。布尔类型的dp[i] [j]：表示区间范围[i,j] （注意是左闭右闭）的子串是否是回文子串，如果是dp[i] [j]为true，否则为false。

    • 确定递推公式：整体上是两种，就是s[i]与s[j]相等，s[i]与s[j]不相等这两种。
      • 当s[i]与s[j]不相等，那没啥好说的了，dp[i][j]一定是false。
      • 当s[i]与s[j]相等时，这就复杂一些了，有如下三种情况:情况一：下标i 与 j相同，同一个字符例如a，当然是回文子串;情况二：下标i 与 j相差为1，例如aa，也是回文子串;情况三：下标：i 与 j相差大于1的时候，例如cabac，此时s[i]与s[j]已经相同了，我们看i到j区间是不是回文子串就看aba是不是回文就可以了，那么aba的区间就是 i+1 与 j-1区间，这个区间是不是回文就看dp[i + 1][j - 1]是否为true。
    • dp数组如何初始化:dp[i][j]初始化为false。
    • 确定遍历顺序:首先从递推公式中可以看出，情况三是根据dp[i + 1][j - 1]是否为true，在对dp[i][j]进行赋值true的。dp[i + 1][j - 1] 在 dp[i][j]的左下角。所以一定要从下到上，从左到右遍历，这样保证dp[i + 1][j - 1]都是经过计算的。
  • class Solution {
      
      
public:
    int countSubstrings(string s) {
      
      
        vector<vector<bool>> dp(s.size(),vector<bool>(s.size(),false));
        int res=0;
        for(int i=s.size()-1;i>=0;i--){
      
      
            for(int j=i;j<s.size();j++){
      
      
                if(s[i]==s[j]){
      
      
                    if(j-i<=1){
      
      
                        dp[i][j] = true;
                        res++;
                    }else if(dp[i+1][j-1]){
      
      
                        dp[i][j] = true;
                        res++;
                    }
                }
            }
        }
        return res;
    }
};

  • 时间复杂度：O(n^2)；空间复杂度：O(n^2)

  • 双指针法:首先确定回文串，就是找中心然后向两边扩散看是不是对称的就可以了。在遍历中心点的时候，要注意中心点有两种情况。一个元素可以作为中心点，两个元素也可以作为中心点。

  • class Solution {
      
      
public:

    int append_pair(const string& s,int i,int j,int n){
      
      
        int res=0;
        while(i>=0 && j<n && s[i]==s[j]){
      
      
            i--;
            j++;
            res++;
        }
        return res;
    }
    int countSubstrings(string s) {
      
      
        int res = 0;
        for(int i=0;i<s.size();i++){
      
      
            res += append_pair(s,i,i,s.size());
            res += append_pair(s,i,i+1,s.size());
        }
        return res;
    }
};

题目：最长回文子序列

  • 给你一个字符串 s ，找出其中最长的回文子序列，并返回该序列的长度。子序列定义为：不改变剩余字符顺序的情况下，删除某些字符或者不删除任何字符形成的一个序列。

  • 回文子串是要连续的，回文子序列可不是连续的！ 回文子串，回文子序列都是动态规划经典题目。

  • 确定dp数组（dp table）以及下标的含义：dp[i][j]：字符串s在[i, j]范围内最长的回文子序列的长度为dp[i][j]。

  • 确定递推公式:在判断回文子串的题目中，关键逻辑就是看s[i]与s[j]是否相同。如果s[i]与s[j]相同，那么dp[i][j] = dp[i + 1][j - 1] + 2;

    • 如果s[i]与s[j]不相同，说明s[i]和s[j]的同时加入 并不能增加[i,j]区间回文子序列的长度，那么分别加入s[i]、s[j]看看哪一个可以组成最长的回文子序列。加入s[j]的回文子序列长度为dp[i + 1][j]。加入s[i]的回文子序列长度为dp[i][j - 1]。那么dp[i][j]一定是取最大的，即：dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]);
    • 在这里插入图片描述

  • dp数组如何初始化:首先要考虑当i 和j 相同的情况，从递推公式：dp[i][j] = dp[i + 1][j - 1] + 2; 可以看出 递推公式是计算不到 i 和j相同时候的情况。当i与j相同，那么dp[i][j]一定是等于1的，即：一个字符的回文子序列长度就是1。

  • class Solution {
      
      
public:
    int longestPalindromeSubseq(string s) {
      
      
        vector<vector<int>> dp(s.size(),vector<int>(s.size()));
        for(int i=0;i<s.size();i++){
      
      
            dp[i][i] = 1;
        }
        for(int i=s.size()-1;i>=0;i--){
      
      
            for(int j=i+1;j<s.size();j++){
      
      
                if(s[i]==s[j]){
      
      
                    dp[i][j] = dp[i+1][j-1]+2;
                }else{
      
      
                    dp[i][j] = max(dp[i+1][j],dp[i][j-1]);
                }
            }
        }
        return dp[0][s.size()-1];
    }
};

  • 时间复杂度: O ( 2 n ) O(2^n) O(2n)；空间复杂度: : O ( 2 n ) O(2^n) O(2n)

猜你喜欢

转载自blog.csdn.net/weixin_43424450/article/details/134206152
今日推荐
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
Java自定义时间格式
同步整形电路
在开发中最最最常用的字符串的属性大集合
Linux 查看端口占用并杀掉
Java基础四：ArrayList
多线程之死锁就是这么简单
mysql 基础命令集
awk 命令详解
Centos6.3编译安装nginx+php步骤
OCR （Optical Character Recognition，光学字符识别）
每日归档
更多
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022