子序列与子串问题

最新推荐文章于 2024-08-03 18:54:56 发布
最新推荐文章于 2024-08-03 18:54:56 发布
阅读量292 收藏 2
点赞数
分类专栏： Online Judge 文章标签： 字符串 算法 hash leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45928272/article/details/118409389
版权

目录


按照顺序看。

最长公共子序列

在这里插入图片描述

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]=max(dp[i-1][j],dp[i][j-1]);
                }
                else
                {
                    dp[i][j]=dp[i-1][j-1]+1;
                }
            }
            
        }
        return dp[text1.size()][text2.size()];
    }
};

上面是返回长度，牛客上还有一道要求返回最长的那个子串。

class Solution {
public:
    /**
     * longest common subsequence
     * @param s1 string字符串 the string
     * @param s2 string字符串 the string
     * @return string字符串
     */
    string LCS(string s1, string s2) {
        int n=s1.size();
        int m=s2.size();
        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(s1[i-1]==s2[j-1])
                {
                    dp[i][j]=dp[i-1][j-1]+1;
                }
                else
                {
                    dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
                }              
            }
        }
        int i=s1.size();
        int j=s2.size();
        string ret;
        while(i > 0 && j > 0)
        {
            //从后往前找，如果相等就--继续找
               if(s1[i-1]==s2[j-1])
               {
                   ret+=s1[i-1];
                   i--;
                   j--;
               }//如果不相等，看自己是由那个推过来的
               else if(dp[i-1][j]>dp[i][j-1])
               {
                  i--;
               }
               else
               {
                   j--;
               }   
        }
        reverse(ret.begin(),ret.end());
        return ret.size()==0?"-1":ret;
    }
};

最长连续递增子序列

在这里插入图片描述

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

         }
         return maxL;
    }
};

最长递增序列

在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        if(nums.size()<=1)
        {
            return nums.size();
        }
        //下标为i时，第i个递增子序列的长度

        //为1个的时候可以看做递增，初始化为1
        vector<int> dp(nums.size(),1);

        int maxVal=INT_MIN;
        //自己不和自己比
        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);
                }
                 maxVal=dp[i]>maxVal?dp[i]:maxVal;
            }
        }
        return maxVal;
        
    }
};

最长连续序列

和无重复字符的最长子串相对照
在这里插入图片描述

class Solution {
public:
    int longestConsecutive(vector<int>& nums) {
            unordered_set<int> hash(nums.begin(),nums.end());
           int maxL=0;
           while(!hash.empty())
           {

                int now=*hash.begin();//找到开始  
                hash.erase(now);//删除他
                int l=now-1;
                int r=now+1;
                   while(hash.find(l)!=hash.end())
                   {
                       //--去找比他小的
                       hash.erase(l);
                      l--;
                   }

                   while(hash.find(r)!=hash.end())
                   {
                       //++去找比他大的
                       hash.erase(r);
                       r++;
                   }
                   maxL=max(maxL,r-l-1);
               }

           return maxL;
    }
};

判断子序列

普通解法

可以转换成求他们两个的最长公共子序列，然后看长度是否和s一样,一样就说明T中有完整的s.

class Solution {
public:
    bool isSubsequence(string s, string t) {
        int n=s.size();
        int m=t.size();
         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
                 {
                     dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
                 }
             }
         }

         return dp[n][m]==n;
    }
};

优化

双指针，当他们两个相等的时候同时向后走，不相等只有T向后走继续找相等。

class Solution {
public:
    bool isSubsequence(string s, string t) {
        int n=s.size();
        int m=t.size();
        int i=0;
        int j=0;
        while(i<n&&j<m)
        {
           if(s[i]==t[j])
           {
               i++;
           }
           j++;

        }
        return i==n;
    }
};

不同的子序列

上一遍博客

无重复字符的最长子串

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
           int n=s.size();
           int i=0;//滑动窗口起始值
           
           int hash[256]={0};//有空格所以不能映射26个字符的相对位置
           int result=0;
           for(int j=0;j<n;++j)
           {
              hash[s[j]]++;
              while(hash[s[j]]==2)
              {
                  hash[s[i]]--;
                  i++;
              }
             result=max(result,j-i+1);
           }
        return result;
    }
};

最长重复数组

class Solution {
public:
    int findLength(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 maxL=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;
            }
            maxL=max(maxL,dp[i][j]);
          }
        }

        return maxL;
    }
};

最长公共子串

和子序列不同的是，子串要求连续。牛客这道题也是要求返回最长的子串

class Solution {
public:
    /**
     * longest common substring
     * @param str1 string字符串 the string
     * @param str2 string字符串 the string
     * @return string字符串
     */
    string LCS(string str1, string str2) {
        int n=str1.size();
        int m=str2.size();
        
        vector<vector<int>> dp(n+1,vector<int>(m+1,0));
        
        int maxL=0;
        int maxi=0;
         for(int i=1;i<=n;++i)
        {
          for(int j=1;j<=m;++j)
          {
              if(str1[i-1]==str2[j-1])
              {
                  dp[i][j]=dp[i-1][j-1]+1;
              }
              
              if(dp[i][j]>maxL)
              {
                maxL=dp[i][j];
                maxi=i-1;
              }
          }
        }
        
        return str1.substr(maxi-maxL+1,maxL);
    }
};

两个字符串的删除操作

第一种方法

dp[i][j]为，以第i个元素结尾的word1，和以底j个元素结尾的word2，要达到相等，所需要删除的最小次数.

这个是两个字符串你都可以删除。开始初始化为可能操作的最大次数。即i。
然后当两个字符相等，不用删除，他就等于上一次的操作次数。
假如不相等
在这里插入图片描述

class Solution {
public:
    int minDistance(string word1, string word2) {
        int n=word1.size();
        int m=word2.size();
       vector<vector<int>> dp(n+1,vector<int>(m+1,0));
          for(int i=0;i<=n;++i)
          {
              dp[i][0]=i;
          }
          for(int j=0;j<=m;++j)
           {
            dp[0][j]=j;   
           }
        
       for(int i=1;i<=n;++i)
       {
           for(int j=1;j<=m;++j)
           {
               if(word1[i-1]==word2[j-1])
               {
                   dp[i][j]=dp[i-1][j-1];
               }
               else
               {
                   //不相等的时候，word1删一个，word2删一个，看哪个大
                   dp[i][j]=min(dp[i-1][j]+1,dp[i][j-1]+1);
                   //也可以直接各删一个，求他们三个的最小
                   dp[i][j]=min(dp[i][j],dp[i-1][j-1]+2);
               }
           }
       }
       return dp[n][m];
    }
};

第二种方法

求出最长公共子序列长度，然后将两个字符串的长度加起来，减去2*最长长度。

class Solution {
public:
    int minDistance(string word1, string word2) {
        int n=word1.size();
        int m=word2.size();
         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(word1[i-1]==word2[j-1])
                 {
                 //上一个最长的长度+1
                     dp[i][j]=dp[i-1][j-1]+1;
                 }
                 else
                 {
                     dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
                 }
             }
         }
         return m+n-2*dp[n][m];


    }
};

编辑距离

判断子序列，不同的子序列，两个字符串的删除操作。这三道题的进阶，具体讲解可以看上一遍博客

回文子串

class Solution {

public:
    int countSubstrings(string s) {

      int n=s.size(); 
      vector<vector<bool>> dp(n,vector<bool>(n,false));     
      for(int i=n-1;i>=0;--i)
       {
           for(int j=i;j<n;++j)
           {
               if(i==j)
               {
                   dp[i][j]=true;
               }
               else if(i==j-1)
               {
                   dp[i][j]=(s[i]==s[j]);
               }
               else
               {
                   dp[i][j]=(dp[i+1][j-1])&&(s[i]==s[j]);
               }
           }
       }
       int count=0;
       for(int i=0;i<n;++i)
       {
           for(int j=0;j<n;++j)
           {
               if(dp[i][j])
               {
                   ++count;
               }
           }
       }
       return count;
    }
};

最长回文子串

class Solution {
public:
    string longestPalindrome(string s) {
        int n=s.size();
       vector<vector<bool>> dp(n,vector<bool>(n,false));
     
       int maxLength=INT_MIN;
       //等会做为sustr的参数
       int begin=0;
       for(int i=n-1;i>=0;--i)
       {
           for(int j=i;j<n;++j)
           {
               if(i==j)
               {
                   dp[i][j]=true;
               }
               else if(i==j-1)
               {
                   dp[i][j]=(s[i]==s[j]);
               }
               else
               {
                   dp[i][j]=(s[i]==s[j])&&(dp[i+1][j-1]);
               }
               if(dp[i][j] && j-i+1>maxLength)
               {
                   maxLength=j-i+1;
                   begin=i;
               }
           }
       }
       return s.substr(begin,maxLength);
       }
};

最长回文序列

楠c
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
利用C++实现最长公共子序列与最长公共子串
12-31
比如序列bo, bg, lg在母串cnblogs与belong中都出现过并且出现顺序与母串保持一致，我们将其称为公共子序列。最长公共子序列（Longest Common Subsequence, LCS），顾名思义，是指在所有的子序列中最长的那一个。子串...
详解Python最长公共子串和最长公共子序列的实现
09-20
**最长公共子序列**与最长公共子串的区别在于，子序列不要求字符间的顺序连续。LCS可以用于衡量两段文本的相似性，比如检测抄袭。解决LCS问题同样使用动态规划，但矩阵的更新规则有所不同。若字符匹配，当前位置的值...
【源代码】程序设计-在校整理-06 最常公共子序列与子串+2048小游戏+KNN简单实例.zip
08-08
【博客源代码】程序设计-在校整理-06 最常公共子序列与子串+2048小游戏+KNN简单实例源代码与数据文件
使用Java实现的计算两字符串相似度+最长公共子序列.zip
05-10
在计算机科学领域，字符串处理是常见的一类任务，其中计算两个字符串的相似度以及找到它们的最长公共子序列（Longest Common Subsequence, LCS）是一个经典的问题。本篇将深入探讨这个问题，以及如何使用Java来解决...
[知识点]-[最短路]
m0_52398496的博客
07-31 539
【代码】[知识点]-[最短路]
【算法】递归实现二分查找（优化）以及非递归实现二分查找
2302_78914800的博客
07-31 218
1.首先确定该数组中间的下标 mid = (left + right) / 2;2.递归完整个数组，依然没有找到，即 left > right 就阶结束递归。2.然后让需要查找的数 findVal 和 arr[mid] 比较。
2023 RoboCom CAIP本科组决赛-RC-u3 兰州拉面派餐系统
m0_68536532的博客
08-03 183
2023 RoboCom CAIP本科组决赛-RC-u3 兰州拉面派餐系统具体实现(不使用优先队列+使用优先队列)
算法日记day 28（贪心之分发饼干|摆动序列|最大子数组和|买卖股票最佳时机）
最新发布
m0_74980681的博客
08-03 327
在判断是否摆动时，需要判断当前节点与左右邻节点的差值是否为一正一负，满足条件才是属于摆动，其中存在一种特殊情况，如：（1,2,2,4,5）属于单调摆动，这种情况总共只有2个摆动，即为边界的两次摆动，因此采用双指针摆动时不能实时更新两个指针的位置，应为一个指针负责判断差值，当差值存在时才能更新另一个指针的位置。可以采用双指针的方法，先将两数组从小到大排序，判断饼干数组中的值是否大于等于胃口数组的值，如果是结果加1，然后饼干数组向前遍历，继续判断，直到饼干数组全部遍历完毕，输出结果数组。，这个孩子会得到满足。
习题20240803（未完成）
weixin_52651540的博客
08-03 536
【代码】习题20240803（未完成）
C语言100道基础拔高题（1）
2303_78660417的博客
07-23 3620
最后按最小值，中间值，最大值的顺序打印即可。解题思路：首先输出由这几个数字所组成的所有三位数，接着再设置条件，使其输出的三位数不重复，下面我们来看下源代码。值得注意的是：所以题目的代码都是作者自行编写，如有更好的思路或者代码的优化，还请指出更正。解题思路：首先找到能整除这个正整数的最小正数，接着重置循环初值，让它继续查找最小正数，最后将得到的所有正数放到一个数组里，最后设置好格式之后循环打印出来。解题思路：首先确定好区间，接着判断是否是素数，素数就是一个大于1的数，除了1和它本身之外，不能被其他数整除。
力扣每日一题 直角三角形
weixin_74141526的博客
08-02 444
中等 数学给你一个二维 boolean 矩阵grid。请你返回使用grid中的 3 个元素可以构建的数目，且满足 3 个元素值为 1。grid2有 2 个直角三角形。0没有直角三角形。2有两个直角三角形。
【算法】退火算法 Simulated Annealing
藓类少女的博客
07-25 1546
退火算法（Simulated Annealing, SA）是一种基于热力学模拟的优化算法，用于求解全局优化问题。它通过模拟物理退火过程来寻找全局最优解。
算法通关：015：最小栈
m0_75257168的博客
08-03 282
因为我是在idea里面写了再复制过来，可能就会出现不一致的问题。
设施农业“AutoML“时代:大模型自动调参,让农业算法模型更简单易用
u010079117的博客
08-03 709
本文将深入探讨LLM和AutoML在设施农业中的应用前景,揭示大模型如何通过自动调参,让农业算法模型的开发和使用变得更加简单易行,为设施农业的智能化升级赋能。
算法 —— 暴力枚举
fen_0108的博客
07-25 4100
第二看纵向宽发生改变，长重置为1，长为1，宽为2的时候，第一行个数为7个，总共有5 x 7 个，长为2，宽为2的时候 第一行个数为6个，共有5 x 6个……首先是横着的长方形，宽始终为1，长不断发生改变，可以看出长为2的时候，第一行个数为6个，总共有6 x 6个，长为3的时候，总共有6 x 5个……这是一道简单的模拟题，枚举出所有可能情况，不会超过规定时间的，以下附上k
c++数组
2401_83073161的博客
08-03 353
第二趟遍历：目的是找到整个序列中次小的值，也就是（动图中第0个位置上的数不在变动，在剩下的 N-1 个数中选出最小的），找到之后将其与剩下的 N-1 个数的第一个数（动图中的第1个位置）交换，这样一来，在整个数组中第一个数（第0位置）就是最小的，第二个数（第1位置）就是次小的。在C++中，数组是一种可以存储**固定大小**的、**相同类型**元素的容器。第一趟遍历的目的是找到整个序列中最小的值，找到之后将其与第一个数（动图中的第0个位置）交换，这样一来，在整个数组中第一个数就是最小的。
(GPLT)上海理工大学校内选拔赛 ABCDEF题解
qq_39804992的博客
08-03 277
思路:采用BFS即可,但需要注意,因为国际象棋和中国象棋共用一个棋盘,但走的规则不同,所以棋盘的矩阵和每次走的标记矩阵要分开储存,并且因为有多次询问,所以每次BFS时都要重置重新初始化标记数组。所以只需将n转化为其对应的二进制字符串,在遍历字符串,若下标x的地方为1,则ans += pow(k,x)思路:贪心,大的数要尽可能与小的数相乘,所以将数组弄成两个,一个降序一个升序,同下标的相乘再加给ans即可。思路:通过观察可以发现,数组中每个数其实就是其下标的二进制位从2的x次方转到K的x次方,
#565. 查找之大编号
Macau889的博客
08-03 141
输入 𝑛(𝑛≤106)n(n≤106) 个不超过 109109 的单调不减的（就是后面的数字不小于前面的数字）非负整数 𝑎1,𝑎2,…,𝑎𝑛a1​,a2​,…,an​，然后进行 𝑚(𝑚≤105)m(m≤105) 次询问。对于每次询问，给出一个整数 𝑞(𝑞≤109)q(q≤109) ，要求输出这个数字在序列中最后一次出现的编号，如果没有找到的话输出 −1−1。第三行 𝑚m 个整数，表示询问这些数字的编号，从 11 开始编号。第一行 22 个整数 𝑛n 和 𝑚m ，表示数字个数和询问次数。
【前端面试】七、算法-Math、数组、数据结构等
weixin_49015558的博客
07-30 563
1.Math 2.数组 3.常见数据结构 4.设计模式
子序列和子串有什么区别
03-08
子序列和子串的区别在于子序列可以不连续，而子串必须是连续的一段。例如，字符串"abcd"的子序列有"a", "b", "c", "d", "ab", "ac", "ad", "bc", "bd", "cd", "abc", "abd", "acd", "bcd", "abcd"，而子串只有"a", ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

楠c

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值