【牛客】【查找两个字符串a,b中的最长公共子串】【动态规划】

查找两个字符串a,b中的最长公共子串_牛客题霸_牛客网

描述

查找两个字符串a,b中的最长公共子串。若有多个，输出在较短串中最先出现的那个。 

注：子串的定义：将一个字符串删去前缀和后缀（也可以不删）形成的字符串。请和“子序列”的概念分开！ 

数据范围：字符串长度1≤length≤300 1≤length≤300 

进阶：时间复杂度：O(n3) O(n3) ，空间复杂度：O(n) O(n) 

输入描述：

输入两个字符串

输出描述：

返回重复出现的字符

示例1

输入：

abcdefghijklmnop
abcsafjklmnopqrstuvw

输出：

jklmnop

假设我们想要知道字符串

s1：abcdefg

s2：abycdefhz

中的最长的公共子串的长度

我们不妨列下面这样一张表

这是我们的初始位置

j所指向的是其上一个位置，也就是0号位置的a

i 所指向的是其上一个位置，也就是0号位置的a

默认我们整张表格中的元素初始化全部都是0。

然后我们发现j指向的a和我们i指向的a能够匹配上，所以

if(str2[j-1]==str1[i-1])
    MSC[i][j]=MSC[i-1][j-1]+1

也就是在我们表中的位置填写上1

然后我们为了记录我们的最长子串

所以我们的初始化最长子串的初始位置是

start=0

然后我们的最长子串的长度maxsize++，也就是从0变成了1

start=0

maxsize=1 

				j
			0	1	2	3	4	5	6	7	8	9
			a	b	y	c	d	e	f	h	z
	0	a	0
i	1	b		1
	2	c
	3	d
	4	e
	5	f
	6	g
	7

 然后我们将i++

然后j重新从1号位置开始往后匹配，寻找str2[j-1]=str1[i-1]的位置

然后我们发现我们的j指向的b和我们i指向的b是能够匹配上的

所以按照我们上面的匹配规则，我们在我们的下面的位置写上2

start=0

将我们的最大子串长度++

maxsize=2 

					j
			0	1	2	3	4	5	6	7	8	9
			a	b	y	c	d	e	f	h	z
	0	a	0
	1	b		1
i	2	c			2
	3	d
	4	e
	5	f
	6	g
	7

 

然后我们将i++

此时i-1指向的是c

然后j重新从1号位置开始往后匹配，寻找str2[j-1]=str1[i-1]的位置

然后我们发现我们的j到4位置，指向j-1的位置的c的时候是可以和我们的i-1指向的c匹配上的

start=0

maxsize=2 

此时我们只有c匹配上了，长度为1，我们是不需要更新我们的maxsize的。

							j
			0	1	2	3	4	5	6	7	8	9
			a	b	y	c	d	e	f	h	z
	0	a	0
	1	b		1
	2	c			2	0
i	3	d					1
	4	e
	5	f
	6	g
	7

 

然后我们将i++

此时i-1指向的是d

然后j重新从1号位置开始往后匹配，寻找str2[j-1]=str1[i-1]的位置

然后我们发现我们的j到5位置，指向j-1的位置的d的时候是可以和我们的i-1指向的c匹配上的

start=0

maxsize=2 

此时我们只有cd匹配上了，长度为2，我们是不需要更新我们的maxsize的。

								j
			0	1	2	3	4	5	6	7	8	9
			a	b	y	c	d	e	f	h	z
	0	a	0
	1	b		1
	2	c			2	0
	3	d					1
i	4	e						2
	5	f
	6	g
	7

 

然后我们将i++

此时i-1指向的是e

然后j重新从1号位置开始往后匹配，寻找str2[j-1]=str1[i-1]的位置

然后我们发现我们的j到6位置，指向j-1的位置的e的时候是可以和我们的i-1指向的c匹配上的

上次一的start和maxsize是下面的数值

start=0

maxsize=2

我们此时的size=3大于我们之前的2，所以我们需要更新我们的maxsize

也就是

maxsize=3

start=i-maxsize=2

									j
			0	1	2	3	4	5	6	7	8	9
			a	b	y	c	d	e	f	h	z
	0	a	0
	1	b		1
	2	c			2	0
	3	d					1
	4	e						2
i	5	f							3
	6	g
	7

 

然后我们将i++

此时i-1指向的是f

然后j重新从1号位置开始往后匹配，寻找str2[j-1]=str1[i-1]的位置

然后我们发现我们的j到7位置，指向j-1的位置的f的时候是可以和我们的i-1指向的c匹配上的

上次一的start和maxsize是下面的数值

start=2

maxsize=3

我们此时的size=4大于我们之前的3，所以我们需要更新我们的maxsize

也就是

maxsize=4

start=i-maxsize=2

										j
			0	1	2	3	4	5	6	7	8	9
			a	b	y	c	d	e	f	h	z
	0	a	0
	1	b		1
	2	c			2	0
	3	d					1
	4	e						2
	5	f							3
i	6	g								4
	7

然后我们的i++，i-1所指向的是g，我们的j是找不到匹配的，我们的搜索就结束了

然后我们就返回

s1.substr(start,maxsize)

就能够将我们的最长子串给取出来的了。

也就是我们的cdef。 

代码实现 

#include <iostream>
#include <string>
#include <vector>
using namespace std;
string getComSubstr(string& str1, string& str2) {
//寻求最短字符串
    if (str1.size() > str2.size())
        swap(str1, str2);
    int len1 = str1.size();
    int len2 = str2.size();
    vector<vector<int>> MSC(len1 + 1, vector<int>(len2 + 1, 0));
    int start = 0, max_size = 0;
    for (int i = 1; i <= len1; ++i) {
        for (int j = 1; j <= len2; ++j) {
            if (str2[j - 1] == str1[i - 1])
                MSC[i][j] = MSC[i - 1][j - 1] + 1;
//如果有更长的公共子串，更新长度
            if (MSC[i][j] > max_size) {
                max_size = MSC[i][j];
//以i结尾的最大长度为max, 则子串的起始位置为i - max
                start = i - max_size;
            }
        }
    }
    return str1.substr(start, max_size);
}
int main() {
    string str1, str2;
    while (cin >> str1 >> str2) {
        string substr = getComSubstr(str1, str2);
        cout << substr << endl;
    }
    return 0;
}