子序列，回文串相关题目

最新推荐文章于 2024-10-03 16:55:58 发布
最新推荐文章于 2024-10-03 16:55:58 发布
阅读量341 收藏
点赞数
文章标签： 算法 leetcode 职场和发展
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42434171/article/details/131941811
版权
文章展示了多个使用动态规划解决的问题，包括寻找最长递增子序列、最长公共子数组/子序列、最大子数组和、判断子序列、字符串编辑距离以及回文子串等。每个问题都通过定义状态转移方程并使用二维数组进行存储来求解。
摘要由CSDN通过智能技术生成

 

class Solution {
public:
    int dp[2510];
    int lengthOfLIS(vector<int>& nums) {
        //dp[i]表示以nums[i]为结尾的最长子序列的长度
        int n=nums.size();
        for(int i=0;i<n;i++){
            dp[i]=1;
        }
        for(int i=1;i<n;i++)
        {
            for(int j=0;j<i;j++)
            {
                if(nums[i]>nums[j])
                {
                    dp[i]=max(dp[i],dp[j]+1);
                }
            }
        }
        int res=1;
        for(int i=0;i<n;i++)
        {
            res=max(res,dp[i]);
        }
        return res;
    }
};

 

class Solution {
public:
    int dp[10005];
    int findLengthOfLCIS(vector<int>& nums) {
        int n=nums.size();
        //dp[i]表示以nums[i]结尾的最长且连续递增的子序列的长度
        for(int i=0;i<n;i++)
        {
            dp[i]=1;
        }
        int res=1;
        for(int i=1;i<n;i++){
            if(nums[i]>nums[i-1])
            {
                dp[i]=dp[i-1]+1;
            }
            else{
                dp[i]=1;
            }
            res=max(res,dp[i]);
        }
        return res;

    }
};

 

class Solution {
public:
    int dp[1005][1005];
    int findLength(vector<int>& nums1, vector<int>& nums2) {
        int res=0;
        //dp[i][j]表示以nums1[i],nums2[j]结尾的 公共的 、长度最长的子数组的长度
        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;
                }
                 res=max(res,dp[i][j]);
            }
           
        }
        return res;
    }
};

 

class Solution {
public:
    int dp[1005][1005];
    int longestCommonSubsequence(string text1, string text2) {
        //dp[i][j]表示以text1[i-1]和text2[j-1]结尾的最长 公共子序列 的长度
        
        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][j-1],dp[i-1][j]);
                }
            }
        }
        return dp[text1.size()][text2.size()];
    }
};

 

class Solution {
public:
    int dp[505][505];
    int maxUncrossedLines(vector<int>& nums1, vector<int>& nums2) {
        //dp[i][j] 表示以nums1[i-1],nums2[j-1]结尾的最长公共子序列的长度

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

class Solution {
public:
    int dp[100005];
    int maxSubArray(vector<int>& nums) {
        int len=nums.size();
        int res=-1e5;
        for(int i=0;i<len;i++){
            res=max(res,nums[i]);
        }
        //dp[i]表示以nums[i]为结尾的最大和的连续子数组
        dp[0]=max(nums[0],0);
        for(int i=1;i<nums.size();i++){
                dp[i]=max(dp[i-1]+nums[i],nums[i]);
                res=max(res,dp[i]);
        }
     
        return res;
    }
};

 

//方法一
class Solution {
public:
    bool isSubsequence(string s, string t) {
        int j=0;
        for(int i=0;i<t.length();i++)
        {
                if(t[i]==s[j])
                {
                    j++;
                }
                
        }
        if(j==s.length())
        {
            return true;
        }
        else{
            return false;
        }
    }
};
//方法二

class Solution {
public:
    int dp[105][10005];
    bool isSubsequence(string s, string t) {
        //dp[i][j] 表示以s[i-1],t[i-1]结尾的s和t的相同子序列的长度

        for(int i=1;i<=s.length();i++)
        {
            for(int j=1;j<=t.length();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];
                    //  0.....i-1
                    //  0.....j-1
                    //由于s[i-1]和[j-1]是属于不同,就相当于把t[j-1]这个字符删掉了.
                }
            }
        }
        int res=dp[s.length()][t.length()];
        if(res==s.length()){
            return true;
        }
        else{
            return false;
        }

    }
};

 

class Solution {
public:
    unsigned long long dp[1005][1005];//注意类型
    int numDistinct(string s, string t) {
        //dp[i-1][j-1]表示以i-1结尾的s中有几个以j-1为结尾的t;
        int sl=s.length();
        int tl=t.length();
        for(int i=0;i<=tl;i++)
        {
            dp[0][i]=0;
        }
        for(int i=0;i<=sl;i++)
        {
            dp[i][0]=1;
        }
        dp[0][0]=1;
        for(int i=1;i<=sl;i++)
        {
            for(int j=1;j<=tl;j++)
            {
                if(s[i-1]==t[j-1]){
                    dp[i][j]=dp[i-1][j-1]+dp[i-1][j];
                    //dp[i][j-1]表示不考虑i-1
                }
                else{
                    dp[i][j]=dp[i-1][j];
                }
            }
        }
        return dp[sl][tl];
    }
};

 

//方法一 首先求两个字符串的最长公共子序列，然后用总长度减掉最长公共子序列长度

class Solution {
public:
    int dp[505][505];
    int minDistance(string word1, string word2) {
    //dp[i][j]表示以i-1结尾的word1,和以j-1结尾的word2的最长公共子序列
          for(int i=1;i<=word1.length();i++)
          {
              for(int j=1;j<=word2.length();j++){
                  if(word1[i-1]==word2[j-1]){
                        dp[i][j]=dp[i-1][j-1]+1;
                  }
                  else
                  {
                      dp[i][j]=max(dp[i][j-1],dp[i-1][j]);
                  }
              }
          }
         
          return word1.length()+word2.length()- 2*dp[word1.length()][word2.length()];

    }
};



//方法二

class Solution {
public:
    int dp[505][505];
    int minDistance(string word1, string word2) {
    //dp[i][j]表示以i-1结尾的word1,和以j-1结尾的word2相同所需的最小步数
    int l1=word1.length();
    int l2=word2.length();
    for(int i=0;i<=l1;i++)
    {
        dp[i][0]=i;
    }
    for(int j=0;j<=l2;j++)
    {
        dp[0][j]=j;
    }
    for(int i=1;i<=l1;i++){
        for(int j=1;j<=l2;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][j-1]+1,dp[i-1][j-1]+2));
                //dp[i-1][j]删掉i-1;
                //dp[i][j-1]删掉j-1;
                //dp[i-1][j-1]两者都删掉
            }
        }
    }
    return dp[l1][l2];
    }
};

 

class Solution {
public:
    int dp[505][505];
    int minDistance(string word1, string word2) {
        //dp[i][j]表示以word1[i-1]结尾的和以word2[j-1]结尾的，1变为2的最小操作数
        int l1=word1.length();
        int l2=word2.length();
        for(int i=0;i<=l1;i++)
        {
            dp[i][0]=i;
        }
        for(int j=0;j<=l2;j++)
        {
            dp[0][j]=j;
        }
        for(int i=1;i<=l1;i++){
            for(int j=1;j<=l2;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][j-1]+1,dp[i-1][j-1]+1));
                    //dp[i-1][j]+1表示删除word1[i-1];
                    //dp[i][j-1]+1表示删除word2[j-1]相当于在word1中添加一个元素
                    //dp[i-1][j-1]+1替换将word1[i-1]替换为word2[j-1]
                }
            }
        }
         return dp[l1][l2];
    }
};

 

class Solution {
public:
    bool dp[1005][1005];
    int countSubstrings(string s) {
        //dp[i][j]表示s[i]...s[j]是不是回文子串
        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]==true)
                           {
                               dp[i][j]=true;
                               res++;
                           }
                           
                       }
                   }
            }
        }
        return res;
    }
};

 

class Solution {
public:
    int dp[1005][1005];
    int longestPalindromeSubseq(string s) {
        //dp[i][j]表示s[i]....s[j]最长回文子序列的长度
        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]);
                    //dp[i+1][j],不考虑s[i]
                    //dp[i][j-1],不考虑s[j-1]
                }
            }
        }
        return dp[0][s.size()-1];
    }
};

我要去看得最远的地方
关注
python笔试例题（快速排序、二分查找、最长无重复子串、最长回文串长度、输出数组中两数相加=target的下标、用两.pdf
12-03
4. **最长回文串长度**：这个问题是寻找一个字符串中最长的回文子串，即正读和反读都一样的字符串。`getLongestPalindrome`函数可能用于解决此问题，但提供的代码片段不完整。通常，可以使用动态规划或者Manacher's ...
删除回文子序列1
08-03
题目中提到，由于字符串只包含两种字符，任何单一字符的子序列都是回文的。这意味着，如果字符串本身是回文，我们只需要删除一次即可使其变为空；如果不是回文，我们可以通过删除所有一个字符（如'a'），然后删除...
ACM-字符串处理专练
01-13
5. **动态规划与字符串**：例如Longest Common Subsequence（LCS）最长公共子序列，Longest Palindromic Substring（LPS）最长回文子串，这些问题是动态规划在字符串处理中的经典应用。 6. **字符串排序与压缩**：...
Java实现 LeetCode 730 统计不同回文子字符串（动态规划）
12-21
在本题中，我们面临的是一个关于字符串处理的问题，具体来说是寻找给定字符串中的所有非空回文子序列，并统计这些子序列的数量。回文序列是指正读和反读都一样的字符序列，例如 "abcba" 和 "abccba" 都是回文序列。...
算法入门经典UVa配套题目pdf
01-18
- 动态规划：解决最优化问题的利器，如背包问题、最长公共子序列、斐波那契数列等，都需要动态规划的思想。 2. **数据结构** - 数组和链表：基础数据结构，理解它们的区别和应用场景，如数组的连续存储和随机访问...
二叉树最小深度
2301_80161204的博客
09-27 475
25[0, 105]
904. 水果成篮
YQ20210216的博客
09-27 374
转化，找出一个最长的子数组长度，子数组中不超过两种类型的水果，要记录水果类型和水果数量，所以要使用unord_map，key来记录水果中类，valuse记录水果数量，当right开始增加的时候，将水果种类加入到哈希表中，当水果中类超过两种时，控制left使得水果种类回到两种。你想要尽可能多地收集水果。你正在探访一家农场，农场从左到右种植了一排果树。这些树用一个整数数组。，返回你可以收集的水果的。
算法：按既定顺序创建目标数组
AWSDN的博客
09-29 234
本文主要介绍按既定顺序创建目标数组问题
DAY17||654.最大二叉树 |617.合并二叉树 |700.二叉搜索树中的搜索 |
2301_79865280的博客
09-29 1297
给定一个不含重复元素的整数数组。通过给定的数组构建最大二叉树，并且输出这个树的根节点。示例 ：构造二叉树一定要，因为要先找到中，才能分割左右子树。本题图解思路：本题做过上一题构建数组确实变得容易很多。代码优化方向有，不用每次找左右子树的时候构建新的数组的话效率就会高很多。（即直接用下标索引直接在原数组上操作）关于加不加if的问题，如果允许空节点进入递归，就不加。
【韩顺平Java笔记】第6章：数组、排序和查找
随手写写
10-02 709
排序是将多个数据，依指定的顺序进行排列的过程。
数据结构（链表的操作算法）
m0_61903191的博客
09-30 470
编写一个程序exp2_2.cpp,采用单链表表示集合(假设同一个集合中不存在重复素)，将其按递增方式排序，构成有序单链表，并求这样的两个集合的并、交和差。(2)依次采用尾插法插入a、b、c、d、e元素。(8)在第4个元素位置上插人1元素。(10)删除单链表h的第3个元素。(6)输出单链表h的第3个元素。(5)判断单链表h是否为空。(4)输出单链表h长度。(7)输出元素a的位置。(1)初始化单链表h。(11)输出单链表h。(12)释放单链表h。(3)输出单链表h。(9)输出单链表h。
【算法】---归并排序（递归非递归实现）
何春秋的博客
10-03 972
归并排序 in Java
代码随想录打卡Day46
weixin_52151595的博客
09-28 463
今天是动态规划的最后一天，终于要结束折磨了！！！今天的两道题，第一道看视频做的，第二道自己AC的，开心！！！！
代码随想录算法训练营day46
qq_56445436的博客
10-01 244
【代码】代码随想录算法训练营day46。
opencv实战项目二十八：基于Shi-Tomasi算法的箱子角点检测
HanWenKing的博客
09-27 1509
随着科技的飞速发展，计算机视觉技术在我们的日常生活中扮演着越来越重要的角色。从无人驾驶汽车到智能手机的摄像头，再到各种智能监控系统，角点检测作为计算机视觉领域的基础技术之一，其应用范围日益广泛。在本文中，我们将聚焦于一种经典的角点检测算法——Shi-Tomasi角点检测算法，并以箱子角点检测为例，探讨其在实际应用中的效果和优势。Shi-Tomasi角点检测算法是基于Harris角点检测算法改进而来的一种高效、稳定的角点检测方法。
算法训练营打卡Day18
Zoe_igxgx的博客
09-29 923
示例 2: 输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 输出: 5 解释: 节点 5 和节点 4 的最近公共祖先是节点 5。示例 1: 输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 输出: 3 解释: 节点 5 和节点 1 的最近公共祖先是节点 3。例如，给定如下二叉树: root = [3,5,1,6,2,0,8,null,null,7,4]
第二十一章 （动态内存管理）
最新发布
code_whiter的博客
10-03 944
1、栈区：在执行函数的时候，函数内的局部变量的储存单元都可以在栈上创建，函数执行结束的时候这些储存单元自动被释放。当是情况2 的时候，原有空间之后没有⾜够多的空间时，扩展的⽅法是：在堆空间上另找⼀个合适⼤⼩的连续空间来使⽤。c 语言还提供了另一个函数free，是专门用来做动态内存的释放和回收的（一般是要与malloc函数同时使用的），函数原型如下。3.返回类型的是void * ，所以malloc函数并不知道开辟空间的类型，具体在使用者使用的时候自己来选择。2. 数组在申明的时候，必须指定数组的长度，
算法笔记（六）——链表
m0_74317866的博客
10-03 371
new head。
python-鸡尾酒疗法/图像相似度/第n小的质数
2401_83954530的博客
10-02 780
该疗法的应用可以减少单一用药产生的抗药性，最大限度地抑制病毒的复制，使被破坏的机体免疫功能部分甚至全部恢复，从而延缓病程进展，延长患者生命，提高生活质量。假设鸡尾酒疗法的有效率为 x，新疗法的有效率为 y，如果 y−x 大于 5%，则效果更好，如果 x−y 大于 5%，则效果更差，否则称为效果差不多。其余 n 行每行两个整数，第一个整数是临床实验的总病例数（小于等于10000)，第二个疗效有效的病例数。第一行包含两个整数 m 和 n，表示图像的行数和列数，中间用单个空格隔开1≤m≤100,1≤n≤100。
题目描述 已知字符串str。 输出字符串str中最长回文串的长度。 输入描述： 输入字符串s.(1<=len(str)<=10000) 输出描述： 输出答案 用c编写
02-06
对于求最长回文串的问题，有一种常见的算法是「最长回文子序列」(Longest Palindromic Subsequence, LPS)算法。 LPS 算法的基本思路是，对于给定的字符串 s，使用动态规划的方法求出它的最长回文子序列。 为了实现...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值