最长子序列&最长子串的题型汇总

最新推荐文章于 2024-02-21 17:18:18 发布
最新推荐文章于 2024-02-21 17:18:18 发布
阅读量4.1k 收藏 18
点赞数 5
分类专栏： java 数据结构 文章标签： 公共子序列 公共子串 最长子序列 动态规划 最长子串
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_19446965/article/details/81668047
版权

1.最长公共子序列的长度

题目：对于两个字符串，请设计一个高效算法，求他们的最长公共子序列的长度，这里的最长公共子序列定义为有两个序列U1,U2,U3...Un和V1,V2,V3...Vn,其中Ui&ltUi+1，Vi&ltVi+1。且A[Ui] == B[Vi]。

给定两个字符串A和B，同时给定两个串的长度n和m，请返回最长公共子序列的长度。保证两串长度均小于等于300。

样例：

"1A2C3D4B56",10,"B1D23CA45B6A",12
返回：

6

解析：求不连续的公共子序列的长度,O(n2)

dp[ i ][ j ] 为A的0 - i 的子串与B的0 - i 的子串的最大公共子序列长度

// 最长公共子序列，动规，O(n2)
	public static int findLCS(String A, String B) {
		int n = A.length();
		int m = B.length();
		int[][] dp = new int[n + 1][m + 1];
		for (int i = 0; i < n; ++i) {
			for (int j = 0; j < m; ++j) {
				if (A.charAt(i) == B.charAt(j)) {
					dp[i + 1][j + 1] = dp[i][j] + 1;
				} else {
					dp[i + 1][j + 1] = Math.max(dp[i][j + 1], dp[i + 1][j]);
				}
			}
		}
		return dp[n][m];
	}

2.打印最长公共子序列

同上，回溯打印。

	// 打印最长公共子序列，动规，O(n2)
	public static String findLCS2(String A, String B) {
		int n = A.length();
		int m = B.length();
		int[] path = new int[n];
		StringBuffer ret = new StringBuffer();
		int[][] dp = new int[n + 1][m + 1];
		for (int i = 0; i < n; ++i) {
			for (int j = 0; j < m; ++j) {
				if (A.charAt(i) == B.charAt(j)) {
					dp[i + 1][j + 1] = dp[i][j] + 1;
				} else {
					dp[i + 1][j + 1] = Math.max(dp[i][j + 1], dp[i + 1][j]);
				}
			}
		}
		int i = n;
		int j = m;
		int k = 0;
		while (dp[i][j] > 0) {
			if (dp[i][j] == dp[i - 1][j])
				i--;
			else if (dp[i][j] == dp[i][j - 1])
				j--;
			else {
				path[k++] = i - 1;
				i--;
				j--;
			}
		}
		for (i = k - 1; i >= 0; i--)
			ret.append(A.charAt(path[i]));
		return ret.toString();
	}

3.最长公共子串的长度

题目：对于两个字符串，请设计一个时间复杂度为O(m*n)的算法(这里的m和n为两串的长度)，求出两串的最长公共子串的长度。这里的最长公共子串的定义为两个序列U1,U2,..Un和V1,V2,...Vn，其中Ui + 1 == Ui+1,Vi + 1 == Vi+1，同时Ui == Vi。

给定两个字符串A和B，同时给定两串的长度n和m。

样例：

"1AB2345CD",9,"12345EF",7

返回：4

解析：求连续的公共子串的长度，O(n2)

dp[ i ][ j ] 为A的以 i 结尾的和子串与B的以 j 结尾的子串最大公共子串长度

// 最长公共子串，动规，O(n2)
	public int findLongest(String A, String B) {
		int n = A.length();
		int m = B.length();
		int[][] dp = new int[n][m];
		int max = 0;
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < m; j++) {
				if (A.charAt(i) == B.charAt(j)) {
					if (i == 0 || j == 0) {
						dp[i][j] = 1; // if(arrA[i]==arrB[0])dp[i][0]=1;if(arrB[j]==arrA[0])dp[0][j]=1;
					} else {
						dp[i][j] = dp[i - 1][j - 1] + 1;
					}
					max = Math.max(dp[i][j], max);
				}
			}
		}
		return max;
	}

4.打印最长公共子串 

例子同上，稍作修改便可：记录最大连续结尾位置

// 打印最长公共子串，动规，O(n2)
	public static String findLongest2(String A, String B) {
		int n = A.length();
		int m = B.length();
		int index_i = 0;// 记录最长公共子串结尾位置
		int[][] dp = new int[n][m];
		int max = 0;
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < m; j++) {
				if (A.charAt(i) == B.charAt(j)) {
					if (i == 0 || j == 0) {
						dp[i][j] = 1; // if(arrA[i]==arrB[0])dp[i][0]=1;if(arrB[j]==arrA[0])dp[0][j]=1;
					} else {
						dp[i][j] = dp[i - 1][j - 1] + 1;
					}
					if (max < dp[i][j]) {
						max = dp[i][j];
						index_i = i;
					}

				}
			}
		}
		String result = A.substring(index_i - max + 1, index_i + 1);
		return result;
	}

5.A串变为B串所需要的最少代价

题目：对于两个字符串A和B，我们需要进行插入、删除和修改操作将A串变为B串，定义c0，c1，c2分别为三种操作的代价，请设计一个高效算法，求出将A串变为B串所需要的最少代价。
给定两个字符串A和B，及它们的长度和三种操作代价，请返回将A串变为B串所需要的最小代价。保证两串长度均小于等于300，且三种代价值均小于等于100。
样例：
        "abc",3,"adc",3,5,3,100
返回：8

解析：

dp[i][j]表示A[0..i-1]变到B[0..j-1]需要的最小代价

长度为i的A修改为长度为j的B可以分为：
1、长度为i的A修改为长度为j-1的B，然后插入j位置的字符；
2、长度为i-1的A修改为长度为j的B，然后删除i位置的字符；
3、长度为i-1的A修改为长度为j-1的B，然后i位置的字符修改为j位置的字符。

public static int Str1ToStr2(String A, String B, int c0, int c1, int c2) {
		int n = A.length();
		int m = B.length();
		int[][] dp = new int[n + 1][m + 1];// dp[i][j]表示A[0..i-1]变到B[0..j-1]需要的最小代价
		for (int i = 1; i < n + 1; i++) {
			dp[i][0] = dp[i - 1][0] + c1;// 删除
		}
		for (int j = 1; j < m + 1; j++) {
			dp[0][j] = dp[0][j - 1] + c0;// 插入
		}
		for (int i = 1; i < n + 1; i++) {
			for (int j = 1; j < m + 1; j++) {
				if (A.charAt(i - 1) == B.charAt(j - 1)) {
					dp[i][j] = dp[i - 1][j - 1];
				} else {
					int cost1 = dp[i][j - 1] + c0;// 插入时的代价
					int cost2 = dp[i - 1][j] + c1;// 删除的代价
					int cost3 = dp[i - 1][j - 1] + c2;// 修改的代价
					dp[i][j] = Math.min(cost3, Math.min(cost1, cost2));
				}
			}
		}
		return dp[n][m];
	}

6.由两个字符串交错组成

题目：对于三个字符串A，B，C。我们称C由A和B交错组成当且仅当C包含且仅包含A，B中所有字符，且对应的顺序不改变。请编写一个高效算法，判断C串是否由A和B交错组成。

给定三个字符串A,B和C，及他们的长度。请返回一个bool值，代表C是否由A和B交错组成。保证三个串的长度均小于等于100。

样例：

    "ABC",3,"12C",3,"A12BCC",6
返回：true

解析：判断C串是否由A和B交错组成。

dp[ i ][ j ] ： A的前个字符与B的前j个字符是否与C的第前i+j-1个字符匹配

public static boolean chkMixture(String A, String B, String C) {
		char[] a = A.toCharArray();
		char[] b = B.toCharArray();
		char[] c = C.toCharArray();
		int n = a.length;
		int m = b.length;
		int v = c.length;
		if (m + n != v) {
			return false;
		}
		boolean[][] dp = new boolean[n + 1][m + 1];// A的前个字符与B的前j个字符是否与C的第前i+j-1个字符匹配
		dp[0][0] = true;
		for (int i = 1; i <= n; i++) {
			if (a[i - 1] == c[i - 1]) {// 只有A的字符串与C匹配
				dp[i][0] = true;
			} else {
				break;
			}
		}

		for (int j = 1; j <= m; j++) {
			if (b[j - 1] == c[j - 1]) {// 只有B的字符串与C匹配
				dp[0][j] = true;
			} else {
				break;
			}
		}

		for (int i = 1; i < n + 1; i++) {
			for (int j = 1; j < m + 1; j++) {
				if (dp[i - 1][j] && a[i - 1] == c[i + j - 1]) {
					dp[i][j] = true;
					continue;
				}
				if (dp[i][j - 1] && b[j - 1] == c[i + j - 1]) {
					dp[i][j] = true;
				}
			}
		}
		return dp[n][m];
	}

7.无重复字符的最长子串

题目：给定一个字符串，找出不含有重复字符的 最长子串 的长度。

样例：

        给定 "abcabcbb" ，没有重复字符的最长子串是 "abc" ，那么长度就是3。

解析：

1. 建立一个256位大小的整型数组来代替哈希表，这样做的原因是ASCII表共能表示256个字符，记录所有字符；

2. 定义两个变量res和left，其中res用来记录最长无重复子串的长度，left指向该无重复子串左边的起始位置，遍历整个字符串，对于每一个遍历到的字符：

  • 如果哈希表中该字符串对应的值为0，说明没有遇到过该字符，则此时计算最长无重复子串，i - left +１，其中ｉ是最长无重复子串最右边的位置，left是最左边的位置；
  • 还有一种情况也需要计算最长无重复子串，就是当哈希表中的值小于left，这是由于此时出现过重复的字符，left的位置更新了，如果又遇到了新的字符，就要重新计算最长无重复子串。

3. 最后每次都要在哈希表中将当前字符对应的值赋值为i+1。

复杂度O(n)

public static int lengthOfLongestSubstring(String s) {
		char[] a = s.toCharArray();
		int[] m = new int[256];
		int res = 0, left = 0;
		for (int i = 0; i < s.length(); ++i) {
			if (m[a[i]] == 0 || m[a[i]] < left) {
				res = Math.max(res, i - left + 1);
			} else {
				left = m[a[i]];
			}
			m[a[i]] = i + 1;
		}
		return res;
	}

改进算法：

public static int lengthOfLongestSubstring2(String s) {
		char[] a = s.toCharArray();
		int[] m = new int[256];
		int res = 0, left = 0;
		for (int i = 0; i < s.length(); ++i) {
			left = Math.max(left, m[a[i]]);
			m[a[i]] = i;
			res = Math.max(res, i - left);
		}
		return res;
	}

8.求和为0的最长连续子数组

解析：

　　通过分析可知，要使其和为0，只有当1和-1的个数相等时，才会成立，但题目要求是连续子序列，所以单纯统计其1和-1个数不可取。

　　由题目中求最长连续子序列，可想到动态规划来求解，动态规划的求解既是寻找其状态转移方程和建立状态转移表的过程

　　设dp[i]为下标为i及其之前数组中所有元素的和，

　　                                             

如图所示，数组为1，-1，1，-1，1，-1，1，-1最后一个值为0，直接满足结果，输出8

如上图，数组1，1，-1，1，1，-1，-1，dp取值为dp[0] = dp[2] = dp[6] = 1; dp[1] = dp[3] = d[5] = 3; dp[4] = 3;

对于每个值，取最后一次出现的位置和第一次出现的位置之差，取它们的最大值，max((6 - 0),(5 - 1),(4 - 4) = 6

private static int solve(int[] numbers, int n) {
        int[] dp = new int[n];
        dp[0] = numbers[0];
        for (int i = 1; i < n; i++) {
            dp[i] = dp[i - 1] + numbers[i];
        }
        Map<Integer, Integer> dpMap = new HashMap<>();
        dpMap.put(0, 0);
        int maxLen = 0;
        for (int i = 0; i < n; i++) {
            if (!dpMap.containsKey(dp[i])) {
                dpMap.put(dp[i], i + 1);
            } else {
                int len = i - dpMap.get(dp[i]) + 1;
                maxLen = maxLen < len ? len : maxLen;
            }
        }
        return maxLen;
    }

9.和不大于M的最大连续数列。 

双指针法  

// 和不大于M的最大连续子数列。
	public static int[] findSubMaxSum(int[] numbers, int M) {
		int[] cumSum = new int[numbers.length + 1]; // obtain cumulative sum.
		int sum = 0;
		cumSum[0] = 0;
		for (int i = 0; i < numbers.length; i++) {
			sum += numbers[i];
			cumSum[i + 1] = sum;
		}
		int l = 0, r = 0; // two pointers start at tip of the array.
		int max = 0;
		int[] ids = new int[2];
		while (l < cumSum.length) {
			while (r < cumSum.length && cumSum[r] - cumSum[l] <= M) {
				r++;
			}
			if (cumSum[r - 1] - cumSum[l] > max) { // since cumSum[0] = 0, thus r always > 0.
				max = cumSum[r - 1] - cumSum[l];
				ids[0] = l;
				ids[1] = r;
			}
			l++;
		}
		System.out.println(max);
		return ids;
	}

10.至少含有K个不同数字的最小连续数列 

双指针法 

// 至少含有K个不同数字的最小连续子数列
	public static int[] findSubMinSum(int[] numbers, int K) {
		int[] cumSum = new int[numbers.length + 1]; // obtain cumulative sum.
		int sum = 0;
		cumSum[0] = 0;
		for (int i = 0; i < numbers.length; i++) {
			sum += numbers[i];
			cumSum[i] = sum;
		}
		int l = 0, r = 0; // two pointers start at tip of the array.
		int min = Integer.MAX_VALUE;
		int[] ids = new int[2];
		HashSet<Integer> set = new HashSet<>();
		while (l < numbers.length) {
			while (r < numbers.length && set.size() < K) {
				set.add(numbers[r]);
				r++;
			}
			int sumStart = l > 0 ? cumSum[l - 1] : 0;
			if (cumSum[r - 1] - sumStart < min) {
				min = cumSum[r - 1] - sumStart;
				ids[0] = l + 1;
				ids[1] = r;
			}

			set.remove(numbers[l]);
            while (l + 1 < numbers.length && numbers[l] == numbers[l + 1]) {
				l++;
			}
			l++;
		}
		System.out.println(min);
		return ids;
	}

 

 

 

 

Rnan-prince
关注
  • 5
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
比较两个字符串A和B，确定A中是否包含B中所有的字符
weixin_30477797的博客
08-11 1261
最近在刷题，碰到一个判断字符串中字符出现的问题，问题如下： 比较两个字符串A和B，确定A中是否包含B中所有的字符。 如题 给出 A = "ABCD" B = "ACD"，返回true 给出 A = "ABCD" B = "AABC"， 返回true 在 A 中出现的 B 字符串里的字符不需要连续或者有序。第二个也为true的原因是因为AA出现两次，但确实都在A字符...
利用C++实现最长公共子序列与最长公共子串
12-31
一、问题描述 子串应该比较好理解，至于什么是子序列，这里给出一个例子：有两个母串 cnblogs belong 比如序列bo, bg, lg在母串cnblogs与belong中都出现过并且出现顺序与母串保持一致，我们将其称为公共子序列。最长公共子序列（Longest Common Subsequence, LCS），顾名思义，是指在所有的子序列中最长的那一个。子串是要求更严格的一种子序列，要求在母串中连续地出现。在上述例子的中，最长公共子序列为blog（cnblogs, belong），最长公共子串为lo（cnblogs, belong）。 二、求解算法 对于母串X=<x1,x2,⋯,xm
最长子串
12-21
最长子串 今天被小伙伴问到最长子串的东西，注意哦，它这里是要求连续的哦，和我之前的最长公共子序列有些不一样，但是捏，大同小异啦最长公共子序列 这次这位小伙伴问的是python的，那我就用python做一下吧（太久没写，真的缩进都看瞎了） 这里先上一种直接查找的方法，无需什么技术含量 把图画出来就一清二楚了 #直接查找\ns1='abcdefgcpppppg\u52a0\u6cb9denf'\ns2='denf\u52a0\u6cb9abcdppdenfcpppppp' import re def find_str(s1,s2): if len(s1)>len(s2): s1,s2=s2,s1 #保证s1小一点
【动态规划】最长子串问题汇总（一）最长上升子序列
最新发布
weixin_57706322的博客
02-21 333
在练习算法的过程中，发现各种子序列问题容易混淆，问题通常是连续，公共，上升（递增）三词随意组合，本系列就最长子串（子序列）问题进行归纳对比。
动态规划——最长子序列、子串问题
chuangshangbeidong的博客
10-25 1455
动态规划——最长（连续）子序列问题0 未完成，待续1. 概述2. 最长子序列（不要求连续）3. 最长连续子序列 0 未完成，待续 1. 概述 其实本问题有两大类，一类是要求连续的，一类是要求不连续的。 先来看子序列与子串的区别，已知原数组为 1, 2, 4, 3, 7, 6, 5] ，则： [1, 2, 4] 为原数组的子串，三个元素收尾相连，中间没有别的元素； [1, 3, 5] 为子序列，各个元素之间可能隔着别的元素。 2. 最长子序列（不要求连续） 3. 最长连续子序列 一维数组，动规数组定义为
最长升序子串
A91A981E的博客
03-15 1825
【问题描述】 输入一行字符串，该字符串只由小写英文字母a-z组成，且其中的字符可以重复，最长不超过10000个字符。 从该字符串中按顺序挑选出若干字符（不一定相邻）组成一个新串，称为“子串”。如果子串中每两个相邻的字符或者相等，或者后一个比前一个大，则称为“升序子串”。编程求出输入字符串的最长升序子串的长度。 例如，由输入字符串abdbch可以构成的升序子串有：abd、abch、bbch、abbch等。其中最长的升序子串是abbch，其长度为5。 【输入形式】 从标准输入读取一行字符串，该串不.
子序列与子串问题（最长公共、最长递增）
qq_43232556的博客
08-18 376
子序列与子串问题（最长公共、最长递增）概念1. 最长公共子序列（LCS）1.1 问题描述1.2 思路 上一期总结了leetcode 中的关于最长回文子串问题的解决方法，大概分为：暴力枚举、动态规划、马拉车算法（Manacher）、中心扩展等，其中有一种可以转换为最长公共子串解决的方法，顿时想到了许多关于子串和子序列的众多问题，其中包括最长公共子序列和最长公共子串的问题，最长递增子序列的问题等等，现在做一下总结。 概念 （1）字符子串：指的是字符串中连续的n个字符，如abcdefg中，ab，cde，fg等都属
顺序表示的串——顺序串4——求最长公共子串
凌空的桨
12-03 1083
例如，两个串分别为S和T，其中S='Icomefromzhengzhou'，T='YoucozhengTo'，则最长公共子串为‘zheng’。 【分析】 该题是上海大学考研题。 用i指针指示串S，用j指针指示串T。对于每个i，从i开始依次与T中的字符依次向后进行比较，如果对应字符相等，则当前公共子串长度length1增加1；如果不相等，则将标志位flag置为0，结束当前次的比较，并将当前次得到子...
经典算法题——最长公共子序列
qq_41663505的博客
11-25 1180
** 解析： ** 此题一共有两个要点： 1.求上述两个最长公共子序列的长度 2.求所有可能出现的最长公共子序列个数，答案可能很大，只要将答案对10^8求余即可 第一个都很好想到，难点在于第二个。下面是对于求最长公共子序列的长度的一个动态规划图： 由此图可以看出，上述两个字符串的最大公共子序列的长度为4 重点： 此图的状态转移方程： 1.当s1[i]=s2[j]时：dp(i,j)=dp(i-1,j-1)+1 2.当s1[i]!=s2[j]并且dp(i-1,j)>=dp(i,j-1)时：dp(i,j.
详解Python最长公共子串和最长公共子序列的实现
12-24
然后求出对角线最长的1的序列，其对应的位置就是最长匹配子串的位置。 def find_lcsubstr(s1, s2): m=[[0 for i in range(len(s2)+1)] for j in range(len(s1)+1)] #生成0矩阵，为方便后续计算，比字符串长度多了...
DP最长子序列子串全总结--GYM 101291 A和M
zjyang12345的博客
04-07 285
一.子序列和子串 子序列中间不一定要连续，子串一定要连续 二.最长上升子序列(LIS) ①算法：（今天VJ的A题，只不过数字换成了字母，问法也有改变） for (int i = 0; i < a.length(); ++i) { dp[i] = 1; for (int j = 0; j < i; ++j) {...
动态规划---最长连续子序列问题
m0_51431003的博客
10-01 3361
动态规划---连续子数列问题
剑指 Offer II 017. 含有所有字符的最短字符串
Tzecto
09-03 475
剑指 Offer II 017. 含有所有字符的最短字符串 给定两个字符串 s 和 t 。返回 s 中包含 t 的所有字符的最短子字符串。如果 s 中不存在符合条件的子字符串，则返回空字符串 “” 。 如果 s 中存在多个符合条件的子字符串，返回任意一个。 注意： 对于 t 中重复字符，我们寻找的子字符串中该字符数量必须不少于 t 中该字符数量。 示例 1： 输入：s = "ADOBECODEBANC", t = "ABC" 输出："BANC" 解释：最短子字符串 "BANC" 包含了字符串 t 的所有字
一个字符串中包含另一个字符串所有字符的最短子串长度？——《编程之美》最短摘要的生成的简化...
weixin_33738578的博客
08-25 828
题目： 给定一个字符串及一个字符串集合A，求该字符串中包含A中所有字符的最短子串长度。 解决方案一： 最直接的方法就是，直接开始遍历：查找任意两个子串之间是否包含str2，如果包含，记录下长度，求得最小值即可。 str1 = "daebfacba"; str2 = "abc"; minLen = len(str1); for i = 0:len(str1) f...
面试题17：包含所有字符的最短字符串
qq_45811949的博客
05-07 743
题目：输入两个字符串s和t，请找出字符串s中包含字符串t的 所有字符的最短子字符串。例如，输入的字符串s为"ADDBANCAD"， 字符串t为"ABC"，则字符串s中包含字符’A’、'B’和’C’的最短子字 符串是"BANC"。如果不存在符合条件的子字符串，则返回空字符串""。如果存在多个符合条件的子字符串，则返回任意一个。 // 利用哈希表和双指针来解题 public String minWindow(String s, String t) { HashMap<Character, In.
lintcode55:比较两个字符串A和B，确定A中是否包含B中所有的字符。
tellsummer的博客
12-12 2854
*样例 给出 A = “ABCD” B = “ACD”，返回 true 给出 A = “ABCD” B = “AABC”， 返回 false 注意 在 A 中出现的 B 字符串里的字符不需要连续或者有序。*看到这个问题一开始没想太多就写了，最初代码如下： public boolean compareStrings(String A, String B) { // wr
给一个很长的字符串str 还有一个字符集比如{a,b,c} 找出str 里包含{a,b,c}的最短子串。要求O(n)
expleeve
06-20 2662
给一个很长的字符串str 还有一个字符集比如{a,b,c} 找出str 里包含{a,b,c}的最短子串。要求O(n). 比如，字符集是a,b,c，字符串是abdcaabcx，则最短子串为abc。
练习3-----输出所有公共的最长子字符串（如果出现重复子串，则输出多次）
一步两步先生的博客
11-29 1541
给定两个字符串A,B（只包含26个英文字母），输出所有公共的最长子字符串（如果出现重复子串，则输出多次） 输入包括两行，每行为一个连续字符串（大小写敏感） 输出包括多行，每行为扫描到的最长公共子串，按照该子串在字符串A（即第一行输入字符串）中出现的先后次序输出 样例输入： abcxyzabcrst opqrstabc 样例输出： abc rst #include&amp;lt;iostream&amp;gt; #...
寻找字符串A中完全包含字符串B的最短子字符串
狂浪生
01-15 5636
基本思路： 已知两个字符串a和b。字符串a的字符有可能重复，字符串b中的字符不重复。 编写一个算法，寻找字符串a的最短子字符串，使得该子字符串包含字符串b中的所有字符。 这是一道典型的动态规划题，有点类似编程之美中最短摘要生成那道题目。 可以使用两个指针t_rear和t_front遍历字符串a。使用两个指针rear和front记录已发现的最短字符串的边界。 使用一个变量cnt记录已经发现...
最长公共子序列和最长公共子串(python)
09-06
最长公共子序列（Longest Common Subsequence, LCS）和最长公共子串（Longest Common Substring）是两个常见的字符串相关问题。 最长公共子序列是指给定两个字符串，要求找到它们之间最长的公共子序列的长度。子序列是从原字符串中删除若干个字符而得到的新字符串，字符在新字符串中的相对顺序与原字符串中的保持一致。动态规划是求解LCS问题的常用方法。 以字符串s1 = "ABCBDAB"和s2 = "BDCAB"为例，可以使用动态规划的方法求解最长公共子序列的长度。首先创建一个二维数组dp，dp[i][j]表示s1的前i个字符和s2的前j个字符之间的最长公共子序列的长度，那么有以下推导关系： 1. 当i=0或j=0时，dp[i][j]=0。 2. 当s1[i-1]=s2[j-1]时，dp[i][j] = dp[i-1][j-1] + 1。 3. 当s1[i-1]!=s2[j-1]时，dp[i][j] = max(dp[i-1][j], dp[i][j-1])。 最后，dp[len(s1)][len(s2)]即为最长公共子序列的长度。 对于最长公共子串，要求找到两个字符串中最长的公共连续子串的长度。连续子串是指在原字符串中连续出现的字符子序列。同样可以使用动态规划来解决该问题。 仍以上述两个字符串s1和s2为例，创建一个二维数组dp，dp[i][j]表示以s1[i-1]和s2[j-1]为结尾的公共子串的长度，那么有以下推导关系： 1. 当i=0或j=0时，dp[i][j]=0。 2. 当s1[i-1]=s2[j-1]时，dp[i][j] = dp[i-1][j-1] + 1。 3. 当s1[i-1]!=s2[j-1]时，dp[i][j] = 0。 最后，dp矩阵中的最大值即为最长公共子串的长度。 以上就是求解最长公共子序列和最长公共子串的常见方法。在实际应用中，我们可以根据具体的问题选择合适的方法，并结合动态规划来解决这些字符串相关的问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值