求字符串s1和s2的最长公共子序列的长度

最新推荐文章于 2023-09-21 09:45:19 发布
最新推荐文章于 2023-09-21 09:45:19 发布
阅读量710 收藏 3
点赞数 2
分类专栏： 大厂面试高频题之数据结构与算法 文章标签： 动态规划 暴力递归 记忆化搜索法 公共子序列 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46838716/article/details/124745590
版权

求字符串s1和s2的最长公共子序列的长度

提示：互联网大厂的经典动态规划题

解决动态规划问题的重要知识！暴力递归的4种经典尝试模型
最关键的就是这个递归函数，解题的核心在这。
互联网大厂的动态规划题目中的四种经典暴力递归尝试模型：
（1）DP1：从左往右的尝试模型，关注i位置结尾，或者i位置开头的情况，或者看i联合i+1,i+2的情况，填表往往是上到下，或者下到上，左到右，右到左。
（2）DP2：从L–R范围上的尝试模型，关注L和R的情况，填表格式非常固定，主对角，副对角，倒回来填
（3）DP3：多样本位置对应的尝试模型，2个样本，一个样本做行，一个样本做列，关注i和j对应位置的情况，先填边界，再填中间
（4）DP4：业务限制类的尝试模型，比如走棋盘，固定的几个方向可以走，先填边界，再填中间。

本题是——DP3：多样本位置对应的尝试模型

文章目录

题目

求字符串s1和s2的最长公共子序列的长度

所谓子序列，就是字符串中不一定连续位置的字符的组合
公共子序列：是2个字符串中公共有的子序列
最长公共子序列：就是2个字符串中最长的那个子序列，其长度就是咱们要求的结果。

一、审题

示例：
s1=ab1cd2ef345gh
s2=opq123rs4tx5yz
其最长公共子序列是：12345，长度ans=5；
在这里插入图片描述

暴力递归尝试DP3：多样本位置对应模型

敏感度：题目，给你2字符串，今后题目给你俩数组，俩个样本，对比进行的题目，显然就是多样本，让你用一个样本做行，一个样本做列，故你要敏感地想到，这就是考你动态规划题目的DP3：多样本位置对应模型

故暴力递归，就知道咋尝试了

显然咱可以这么做：
定义暴力递归函数**f(s1,i, s2,j)**为求：从s1的0–i范围与s2的0–j范围上的最长公共子序列的长度是？

主函数咋调用？f(s1,N-1, s2,M-1)，N是s1长度，M是s2长度
在这里插入图片描述

多样本位置模型，关注的是i和j结尾的情况如何如何？
那咱们就来分析一下，究竟f(s1,i, s2,j)是如何处理的：
（1）最长公共子序列common：不以 s1的i位置结尾，不以 s2的j位置结尾，那相当于扩展i和j没意义
所以结果ans应该是f(s1,i - 1, s2,j - 1)
在这里插入图片描述
（2）最长公共子序列common：不以 s1的i位置结尾，以 s2的j位置结尾，那相当于扩展i没意义
所以结果ans应该是f(s1,i - 1, s2,j)
在这里插入图片描述
（3）最长公共子序列common：以 s1的i位置结尾，不以 s2的j位置结尾，那相当于扩展j没意义
所以结果ans应该是f(s1,i, s2,j - 1)
在这里插入图片描述
（4）最长公共子序列common：以 s1的i位置结尾，以 s2的j位置结尾，那必然是当**s1[i]=s2[j]**才行（这个条件千万别漏掉！！！）
所以结果ans应该是f(s1,i - 1, s2,j - 1) + 1

也就这么几种情况，以上四种情况取最大值。

（0）最基本的情况就是当i=0，切j=0时的状况，看看俩相等与否
在这里插入图片描述

另外，看i=0，整行，如果s2的0–j-1范围中有一个s1的i字符，那就是1，否则看i字符和j字符是否相等了？相等为1，不等就0
在这里插入图片描述
另外，看j=0，整列，如果s1的0–i-1中有一个s2的j字符，那就是1，否则看i字符和j字符是否相等了？相等为1，不等就0
在这里插入图片描述

这很好理解吧？

okay，咱们逻辑已经捋清了，所以手撕暴力递归的代码岂不是非常非常非常非常简单了！！！

//定义暴力递归函数**f(s1,i, s2,j)**为求：**从s1的0--i范围与s2的0--j范围上的最长公共子序列的长度**是？
    public static int f(char[] str1, char[] str2, int i, int j){
        //（0）最基本的情况就是当i=0，切j=0时的状况，看看俩相等与否
        if (i == 0 && j == 0) return str1[i] == str2[j] ? 1 : 0;
        //另外，看i=0，整行，如果s2的0--j-1范围中有一个s1的i字符，那就是1，否则看i字符和j字符是否相等了？相等为1，不等就0
        if (i == 0 && j > 0) return Math.max(f(str1, str2, i, j - 1), str1[i] == str2[j] ? 1 : 0);
        //另外，看j=0，整列，如果s1的0--i-1中有一个s2的j字符，那就是1，否则看i字符和j字符是否相等了？相等为1，不等就0
        if (j == 0 && i > 0) return Math.max(f(str1, str2, i - 1, j), str1[i] == str2[j] ? 1 : 0);
        //其余ij
        //（1）最长公共子序列common：**不以** s1的i位置结尾，**不以** s2的j位置结尾，那相当于扩展i和j没意义
        //所以结果ans应该是f(s1,i - 1, s2,j - 1)
        int p1 = f(str1, str2, i - 1, j - 1);
        //（2）最长公共子序列common：**不以** s1的i位置结尾，**以** s2的j位置结尾，那相当于扩展i没意义
        //所以结果ans应该是f(s1,i - 1, s2,j)
        int p2 = f(str1, str2, i - 1, j);
        //（3）最长公共子序列common：**以** s1的i位置结尾，**不以** s2的j位置结尾，那相当于扩展j没意义
        //所以结果ans应该是f(s1,i, s2,j - 1)
        int p3 = f(str1, str2, i, j - 1);
        //（4）最长公共子序列common：**以** s1的i位置结尾，**以** s2的j位置结尾，那必然是**s1[i]=s2[j]**才行
        //所以结果ans应该是f(s1,i - 1, s2,j - 1) **+ 1**
        int p4 = -1;
        if (str1[i] == str2[j]) p4 = f(str1, str2, i - 1, j - 1) + 1;
        //也就这么几种情况，以上四种情况取最大值。
        return Math.max(Math.max(p1, p2), Math.max(p3, p4));
    }
    //主函数调用：
    public static int maxLenOflongestCommonSubString(String s1, String s2){
        if (s1.compareTo("") == 0 || s1.length() == 0 ||
                s2.compareTo("") == 0 || s2.length() == 0) return 0;

        char[] str1 = s1.toCharArray();
        char[] str2 = s2.toCharArray();

        return f(str1, str2, str1.length - 1, str2.length - 1);
    }

    public static void test(){
        String s1="ab1cd2ef345gh";
        String s2="opq123rs4tx5yz";
//        String s1="abcde";
//        String s2="abcdf";

        System.out.println(maxLenOflongestCommonSubString(s1, s2));
    }

    public static void main(String[] args) {
        test();
    }

测试时速度很慢的5

修改记忆化搜索法：傻缓存dp表跟随暴力递归代码

记忆化搜索法，无非就是用一个dp表，把可能的i和j的各种状态组合的最佳结果，存到表格dp[i][j]中，
如果递归过程中，发现dp[i][j]已经求过了，就不要暴力递归继续去求了，直接返回dp[i][j]省时间

咱就来准备一个dp
由于暴力递归就2个变量i和j自然就是填写一个二维的表
i取0–N-1
j取0–M-1
故dp是N×M维的矩阵
在这里插入图片描述
dp[i][j]的含义就是暴力递归的含义：从s1的0–i范围与s2的0–j范围上的最长公共子序列的长度是？

怎么填，完全根据暴力递归的代码来写

//改为傻缓存dp表：
    // 定义暴力递归函数**f(s1,i, s2,j)**为求：
    // **从s1的0--i范围与s2的0--j范围上的最长公共子序列的长度**是？
    public static int fDP(char[] str1, char[] str2, int i, int j, int[][] dp){
        if (dp[i][j] != -1) return dp[i][j];
        //（0）最基本的情况就是当i=0，切j=0时的状况，看看俩相等与否
        if (i == 0 && j == 0) {
            dp[i][j] = str1[i] == str2[j] ? 1 : 0;
            return dp[i][j];
        }
        //另外，看i=0，整行，如果s2的0--j-1范围中有一个s1的i字符，那就是1，否则看i字符和j字符是否相等了？相等为1，不等就0
        if (i == 0 && j > 0) {
            dp[i][j] = Math.max(fDP(str1, str2, i, j - 1, dp), str1[i] == str2[j] ? 1 : 0);
            return dp[i][j];
        }
        //另外，看j=0，整列，如果s1的0--i-1中有一个s2的j字符，那就是1，否则看i字符和j字符是否相等了？相等为1，不等就0
        if (j == 0 && i > 0){
            dp[i][j] = Math.max(fDP(str1, str2, i - 1, j, dp), str1[i] == str2[j] ? 1 : 0);
            return dp[i][j];
        }
        //其余ij
        //（1）最长公共子序列common：**不以** s1的i位置结尾，**不以** s2的j位置结尾，那相当于扩展i和j没意义
        //所以结果ans应该是f(s1,i - 1, s2,j - 1)
        int p1 = fDP(str1, str2, i - 1, j - 1, dp);
        //（2）最长公共子序列common：**不以** s1的i位置结尾，**以** s2的j位置结尾，那相当于扩展i没意义
        //所以结果ans应该是f(s1,i - 1, s2,j)
        int p2 = fDP(str1, str2, i - 1, j, dp);
        //（3）最长公共子序列common：**以** s1的i位置结尾，**不以** s2的j位置结尾，那相当于扩展j没意义
        //所以结果ans应该是f(s1,i, s2,j - 1)
        int p3 = fDP(str1, str2, i, j - 1, dp);
        //（4）最长公共子序列common：**以** s1的i位置结尾，**以** s2的j位置结尾，那必然是**s1[i]=s2[j]**才行
        //所以结果ans应该是f(s1,i - 1, s2,j - 1) **+ 1**
        int p4 = -1;
        if (str1[i] == str2[j]) p4 = fDP(str1, str2, i - 1, j - 1, dp) + 1;
        //也就这么几种情况，以上四种情况取最大值。
        dp[i][j] = Math.max(Math.max(p1, p2), Math.max(p3, p4));
        return dp[i][j];
    }
    //主函数调用：
    public static int maxLenOflongestCommonSubStringDP(String s1, String s2){
        if (s1.compareTo("") == 0 || s1.length() == 0 ||
                s2.compareTo("") == 0 || s2.length() == 0) return 0;

        char[] str1 = s1.toCharArray();
        char[] str2 = s2.toCharArray();
        int N = str1.length;
        int M = str2.length;
        int[][] dp = new int[N][M];
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < M; j++) {
                dp[i][j] = -1;//初始化
            }
        }

        return fDP(str1, str2, str1.length - 1, str2.length - 1, dp);
    }

    public static void test(){
        String s1="ab1cd2ef345gh";
        String s2="opq123rs4tx5yz";
//        String s1="abcde";
//        String s2="abcdf";

//        System.out.println(maxLenOflongestCommonSubString(s1, s2));
        System.out.println(maxLenOflongestCommonSubStringDP(s1, s2));
    }

    public static void main(String[] args) {
        test();
    }

秒杀，瞬间出结果：5

暴力递归到精细化动态规划填表dp：转移方程

那么既然咱有了暴力递归代码

很容易就能直接改为精细化填写dp表的动态规划方法：
咱就来准备一个dp
由于暴力递归就2个变量i和j自然就是填写一个二维的表
i取0–N-1
j取0–M-1
故dp是N×M维的矩阵
在这里插入图片描述
dp[i][j]的含义就是暴力递归的含义：从s1的0–i范围与s2的0–j范围上的最长公共子序列的长度是？
咱们咋求每一个格子呢？

自然是根据暴力递归的代码来求

//（0）最基本的情况就是当i=0，切j=0时的状况，看看俩相等与否
        if (i == 0 && j == 0) return str1[i] == str2[j] ? 1 : 0;
        //另外，看i=0，整行，如果s2的0--j-1范围中有一个s1的i字符，那就是1，否则看i字符和j字符是否相等了？相等为1，不等就0
        if (i == 0 && j > 0) return Math.max(f(str1, str2, i, j - 1), str1[i] == str2[j] ? 1 : 0);
        //另外，看j=0，整列，如果s1的0--i-1中有一个s2的j字符，那就是1，否则看i字符和j字符是否相等了？相等为1，不等就0
        if (j == 0 && i > 0) return Math.max(f(str1, str2, i - 1, j), str1[i] == str2[j] ? 1 : 0);

这三行代码，足够填dp表中0 0 格子，0行0列

根据其余ij的代码：

```java
//（1）最长公共子序列common：**不以** s1的i位置结尾，**不以** s2的j位置结尾，那相当于扩展i和j没意义
        //所以结果ans应该是f(s1,i - 1, s2,j - 1)
        int p1 = f(str1, str2, i - 1, j - 1);
        //（2）最长公共子序列common：**不以** s1的i位置结尾，**以** s2的j位置结尾，那相当于扩展i没意义
        //所以结果ans应该是f(s1,i - 1, s2,j)
        int p2 = f(str1, str2, i - 1, j);
        //（3）最长公共子序列common：**以** s1的i位置结尾，**不以** s2的j位置结尾，那相当于扩展j没意义
        //所以结果ans应该是f(s1,i, s2,j - 1)
        int p3 = f(str1, str2, i, j - 1);
        //（4）最长公共子序列common：**以** s1的i位置结尾，**以** s2的j位置结尾，那必然是**s1[i]=s2[j]**才行
        //所以结果ans应该是f(s1,i - 1, s2,j - 1) **+ 1**
        int p4 = -1;
        if (str1[i] == str2[j]) p4 = f(str1, str2, i - 1, j - 1) + 1;
        //也就这么几种情况，以上四种情况取最大值。
        return Math.max(Math.max(p1, p2), Math.max(p3, p4));

可知，其余dp[i][j]（表格中粉色五角星那），其实根据暴力递归中的（1）（2）（3）（4）四种情况的最大值，发现，dp[i][j]依赖：
i - 1, j - 1格子【ij的左上角】
i - 1, j格子【ij的上方格子】
i, j - 1格子【ij的左方格子】

最后咱们要的是红色五角星那个格子为结果：ans = dp[N - 1][M - 1]

因此，我们填写dp的代码就很容易手撕了：

//精细化DP
    //主函数：
    public static int maxLenOflongestCommonSubStringDP2(String s1, String s2){
        if (s1.compareTo("") == 0 || s1.length() == 0 ||
                s2.compareTo("") == 0 || s2.length() == 0) return 0;

        char[] str1 = s1.toCharArray();
        char[] str2 = s2.toCharArray();
        int N = str1.length;
        int M = str2.length;
        int[][] dp = new int[N][M];

        //（0）最基本的情况就是当i=0，切j=0时的状况，看看俩相等与否
        dp[0][0] = str1[0] == str2[0] ? 1 : 0;
        //另外，看i=0，整行，如果s2的0--j-1范围中有一个s1的i字符，那就是1，否则看i字符和j字符是否相等了？相等为1，不等就0
        for (int j = 1; j < M; j++) {//填写0行
            dp[0][j] = Math.max(dp[0][j - 1], str1[0] == str2[j] ? 1 : 0);
        }
        //另外，看j=0，整列，如果s1的0--i-1中有一个s2的j字符，那就是1，否则看i字符和j字符是否相等了？相等为1，不等就0
        for (int i = 1; i < N; i++) {//填写0列
            dp[i][0] = Math.max(dp[i - 1][0], str1[i] == str2[0] ? 1 : 0);
        }
        //其余ij
        for (int i = 1; i < N; i++) {
            for (int j = 1; j < M; j++) {
                //（1）最长公共子序列common：**不以** s1的i位置结尾，**不以** s2的j位置结尾，那相当于扩展i和j没意义
                //所以结果ans应该是f(s1,i - 1, s2,j - 1)
                int p1 = dp[i - 1][j - 1];
                //（2）最长公共子序列common：**不以** s1的i位置结尾，**以** s2的j位置结尾，那相当于扩展i没意义
                //所以结果ans应该是f(s1,i - 1, s2,j)
                int p2 = dp[i - 1][j];
                //（3）最长公共子序列common：**以** s1的i位置结尾，**不以** s2的j位置结尾，那相当于扩展j没意义
                //所以结果ans应该是f(s1,i, s2,j - 1)
                int p3 = dp[i][j - 1];
                //（4）最长公共子序列common：**以** s1的i位置结尾，**以** s2的j位置结尾，那必然是**s1[i]=s2[j]**才行
                //所以结果ans应该是f(s1,i - 1, s2,j - 1) **+ 1**
                int p4 = -1;
                if (str1[i] == str2[j]) p4 = p1 + 1;
                //也就这么几种情况，以上四种情况取最大值。
                dp[i][j] = Math.max(Math.max(p1, p2), Math.max(p3, p4));
            }
        }

        return dp[N - 1][M - 1];
    }

    public static void test(){
        String s1="ab1cd2ef345gh";
        String s2="opq123rs4tx5yz";
//        String s1="abcde";
//        String s2="abcdf";

//        System.out.println(maxLenOflongestCommonSubString(s1, s2));
//        System.out.println(maxLenOflongestCommonSubStringDP(s1, s2));
        System.out.println(maxLenOflongestCommonSubStringDP2(s1, s2));
    }

    public static void main(String[] args) {
        test();
    }

是不是很简单，这些转移方程都不是凭空想想出来的，完全是根据暴力递归代码改写的！
结果5

总结

提示：重要经验：

1）动态规划的关键在暴力递归的尝试，有4个模型
2）暴力递归在笔试要改为记忆化搜索方案（傻缓存dp表跟随），面试要改为精细化动态规划填写dp表，把转移方程搞出来
3）笔试求AC，可以不考虑空间复杂度，但是面试既要考虑时间复杂度最优，也要考虑空间复杂度最优。

冰露可乐
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
给定两个字符串s1,s2，写函数输出s1和s2的最长公共子串
JackieDYH的博客
08-18 1260
varsubS=""; varsubLen=0; vars1="dlajadoueowfljlj0000123456ldjfl1111111111111alfj"; vars2="lfjaldjuaoewnn0000123456jdfjsiol1111111111111alf"; for(leti=0;i<s1.length;i++){ for(letj=1;j<=s1.length-i;j++){ if(s2.indexOf(s1.subs...
使用Java实现的计算两字符串相似度+最长公共子序列.zip
05-10
最长公共子序列问题定义如下：给定两个字符串S1和S2，找到一个非空字符串Z，使得Z是S1和S2的子序列，且Z的长度最大。子序列是指在不改变字符顺序的情况下，可以通过删除原字符串中的某些字符得到的新字符串。例如，...
最长公共子序列
Closure
03-11 201
有两个字符串S1和S2,求一个最长公共子串，即求字符串S3,它同时为S1和S2的子串，且要求它的长度最长，并确定这个长度。这个问题被我们称为最长公共子序列问题。 与求最长递增子序列一样，我们首先将原问题分割成一些子问题，我们用dp[i][j]表示S1中前i个字符与S2中前j个字符分别组成的两个前缀字符串的最长公共子串长度。显然的，当i、j较小时我们可以直接得出答案，最长公共子序列问题的递推条件:...
最长连续子序列偏移_[动态规划] 最长公共子序列问题（LCS）和最长公共子串问题...
weixin_39795845的博客
11-20 187
最长公共子序列问题（LCS）问题描述给定两个字符串s1和s2，长度分别为m和n，要求找出它们最长的子序列，并返回其长度。如：s1 = “HelloWorld”s2 = “loop”它们的最长公共子序列为“loo”，长度为3。算法描述①定义数组dp[m+1][n+1]，dp[i][j]表示字符串s1的第一个字符到第i个字符组成的字符串和字符串s2的第一个字符到第j个字符的最长公共子序列，即s1.su...
写一个函数，传入两个字符串s1,s2，返回最长公共子串的长度
Baymax_wyl的博客
08-20 2524
package tuniu; /** * @author wyl * @time 2018年8月20日下午12:40:37 * 写一个函数，传入两个字符串str1,str2，返回最长公共子串的长度 * * 首先以较短的那个字符串为准开始匹配，因为就算全部字符串都能匹配到， * 那也只能是最短字符串的全部。如果以较多字符串来匹配的话，那么匹配成功后， * 可能还会在后面全匹配到，当...
2021-6
04-14 693
1247. 交换字符使得字符串相同（中等） 有两个长度相同的字符串s1和s2，且它们其中只含有字符"x"和"y"，你需要通过「交换字符」的方式使这两个字符串相同。 每次「交换字符」的时候，你都可以在两个字符串中各选一个字符进行交换。 交换只能发生在两个不同的字符串之间，绝对不能发生在同一个字符串内部。也就是说，我们可以交换s1[i]和s2[j]，但不能交换s1[i]和s1[j]。 最后，请你返回使s1和s2相同的最小交换次数，如果没有方法能够使得这两个字符串相同，...
求两个字符串的最长公共子序列.pdf
11-25
我们可以构建一个 m x n 的二维数组 A，其中 A[i][j] 表示 X 的前 i 个字符和 Y 的前 j 个字符的最长公共子序列的长度。 可以使用以下递归公式来计算 A[i][j]： * 如果 X[i] == Y[j]，则 A[i][j] = A[i-1][j-1] + ...
基于C++实现的通过动态规划查找最长公共子序列计算字符串之间相似度.zip
最新发布
05-10
1. 如果s1的第i个字符和s2的第j个字符相等，那么dp[i][j] = dp[i-1][j-1] + 1，表示我们找到了一个公共字符，所以当前最长公共子序列长度在上一状态的基础上加1。 2. 如果s1的第i个字符和s2的第j个字符不相等，我们...
算法实现最长公共子序列问题（动态规划和KR算法）
04-08
否则，L[i][j]为L[i-1][j]和L[i][j-1]中的较大值，表示不考虑当前字符时的最长公共子序列长度。 Python实现LCS可以这样写： ```python def lcs(s1, s2): m, n = len(s1), len(s2) L = [[0] * (n + 1) for _ in ...
详解Python最长公共子串和最长公共子序列的实现
12-24
LCS问题就是求两个字符串最长公共子串的问题。解法就是用一个矩阵来记录两个字符串中所有位置的两个字符之间的匹配情况，若是匹配则为1,否则为0。然后求出对角线最长的1的序列，其对应的位置就是最长匹配子串的位置...
给定两个字符串求两个字符的最长公共子序列长度问题的解法
z1171127310的博客
11-06 1583
给定两个字符串str1和str2，求两个字符的最长公共子序列长度
程序设计近期学习总结
wcxyky的博客
03-24 177
一 STL STL说明: 定义集合类型（STL中不同数据结构）变量，数据元素类型在尖括号内说明，通过变量名.成员函数去执行具体功能。 一.栈(stack) 1.栈是一种先进后出的数据结构，只能操作最顶端的元素 2.头文件#include<stack> 格式 stack<int>(尖括号内是堆栈内元素的类型，可以是结构体等其他类型）s 3.操作: s.empty()----...
给定两个字符串s1与s2的最大公共字符串
大魚的个人博客，如有不足，欢迎指正。
12-14 717
题目： 求给定两个字符串s1与s2的最大公共字符串。利用动态规划结合滚动数组求解。关键注释都在代码块中。 #include<cstdio> #include<algorithm> #include<cstdlib> #include<cstring> #include<iostream> using namespace std; ...
数据结构与算法之最长公共子串
weixin_47225948的博客
09-21 3806
最长公共子串问题是指给定两个字符串S1和S2，求它们的公共子串中最长的那一个。其实就是求两个字符串的最长重复子串。最朴素的算法就是枚举S1和S2的每一对子串，然后判断它们是否相等，时间复杂度是O(n^3)。但是这种算法效率太低，无法满足实际需求。一般采用动态规划的思想进行求解，令dp[i][j]表示以S1的前i个字符和S2的前j个字符为结尾的公共子串的长度，当S1[i]=S2[j]时，dp[i][j]=dp[i-1][j-1]+1；否则dp[i][j]=0。最后找出dp[i][j]的最大值即可。
算法-求两个字符串的子串和子序列
njh1147394013的博客
03-12 148
求两个字符串的子串和子序列
【算法】提取字符串序列
成长之路
11-17 583
给定一个字符串，请将其中的所有数字串提取，并将每个数字串作为整数看待（假设可以用int 表示），按从小到大顺序输出结果，输出的整数之间以逗号间隔。如果没有数字，则输出0；例如：*1234.345#6781ad9jk81-11101?在一行内输入一串符号，长度不大于300。输入数据保证提取的整数不超过10^9。函数。我们主要需要解决的问题就是第1步了。
求解字符串所包含子串的个数
热门推荐
只如初见0706的博客
03-01 7万+
1、子串：串中任意个连续的字符组成的子序列称为该串的子串（连续、连续、连续！重要的事情说三遍）备注：空串属于子串2、串中字符均不相同：n个字符构成的字符串，假设每个字符都不一样，问有多少个子串答案：n(n+1)/2+1友情提示：每个字符均不相同解析：包含1个字符的子串共n个包含2个字符的子串共n-1个包含3个字符的子串共n-2个包含4个字符的子串共n-3个.。。。。。包含n个字符的子串共1个空串1...
String类 与 String类中的常用方法
qq_56501283的博客
06-16 452
目录前言：1.String类的概述2.字符串的两种创建方式 1.String s = “abc”; 2.String s = new String(“abc”); 3.String类常用方法String类是引用类型，不是基本类型。 先在栈中创建一个对String类的对象引用变量s，然后去字符串常量池中查找有没有"abc", 如果没有则在常量池中添加”abc”, s引用变量指向常量池中 的”abc”，如果常量池中有,则直接指向改地址即可,不用重新创建. 一概在堆中创建新对象，值存储在堆内存的
字符串如何求给定子序列的数量（动态规划求解） 模板
m0_55682843的博客
10-10 2830
给定一个字符串 S 和一个字符串 T，计算在 S 的子序列中 T 出现的个数 假设 S=”rabbbit“ ，T=”rabbit“ 下面是图例 最终结果是dp[T.size()][S.size()] 每当T[i] == S[j]时， dp[i][j]会增加， 比如S= rabb, T= rab. 此时dp[i][j] = dp[i][j-1] + x （x为增加量） 当T[i] != S[j]时 dp[i][j] 会不变 x是什么呢?，对于例子S=rabbb， T=rabb, x为...
两个字符串的最长公共子序列长度_求2个字符串的最长公共子序列和最长公共子字符串...
06-07
具体的实现方法是，定义一个二维数组 dp[i][j] 表示字符串 s1 的前 i 个字符和字符串 s2 的前 j 个字符的最长公共子序列长度。那么，状态转移方程可以写成： - 如果 s1[i-1] == s2[j-1]，则 dp[i][j] = dp[i-1][j-1...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

冰露可乐

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

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

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

打赏作者

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

抵扣说明：

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

余额充值