动态规划-最长公共子序列【LCS】-CSDN博客

本文链接：https://blog.csdn.net/slime_kirito/article/details/47780039

最长公共子序列简称LCS

问题描述

给定两个序列X(x1,x2,x3…xm)和Y(y1, y2, y3…yn)，求长度最大的公共子序列的长度。

例如：1,5,2,6,8,7 和 2,3,5,6,9,8,4 的LCS为5,6,8（另一个解是2,6,8）

dp[i][j]记录X[1~i]与Y[1~j] 的LCS 的长度

状态转移方程：

O(n*n)

/*主要代码*/
const int MAXN = 1000;
int dp[MAXN][MAXN];
for (int i = 1; i <= n; i++)
{
	for (int j = 1; j <= n; j++)
	{
		if (x[i] == y[j])
		{
			dp[i][j] = dp[i - 1][j - 1] + 1;
		}
		else
		{
			dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
		}
	}
}
cout << dp[n][n] << endl;

优化：减少空间

先看看LCS的过程图：

通过观察发现，状态dp[i][j]只与当前行(dp[i][j-1])和上一行(dp[i-1][j]，dp[i-1][j-1])的状态有关。这样，我们可以设置2个一维数组c1[],c2[]，其中c1[]保存上一行的状态信息，c2[]更新当前行的状态信息，更新完毕之后再将c2[]的状态信息复制到c1[]中，循环结束后c1[length_B]就是所求LCS的最大长度，从而降低了空间需求。

这样空间复杂度由原来的dp[maxn][maxn]变成dp[2][maxn]，大大地减少了空间。

#include <iostream>
#include<cstring>
using namespace std;
const int MAXN = 5001;
char str1[MAXN], str2[MAXN];
int i, j, len1, len2, c1[MAXN], c2[MAXN];
int main()
{
     while (scanf("%s", str1) != EOF)
	 {
		scanf("%s", str2);
        len1 = strlen(str1), len2 = strlen(str2);
		memset(c1, 0, sizeof(c1));
        for (i = 0; i <= len1; i++)
		{
            for (j = 0; j <= len2; j++)
			{
				if (str1[i] == str2[j])
				{
					c2[j + 1] = c1[j] + 1;
				}
				else
				{
					c2[j + 1] = c2[j] > c1[j + 1] ? c2[j] : c1[j + 1];
				}
			}
			for (j = 1; j <= len2; j++)
			{
				c1[j] = c2[j];
			}
		}
        printf("%d\n", c1[len2]);

	}
     return 0;
}

再优化：减少时间

对于上面的思路：每次都要进行更新完毕之后再将c2[]的状态信息复制到c1[]中，这样当串的长度很大是，会花掉很多时间。那么我们可以使用滚动数组：

这里重点讲一下滚动数组在这个题目中的应用.自己目前理解的应用滚动数组的目的就是减少空间开销.首先可以在纸上简单模拟一下DP的转移过程.确定好最少行数或者列数之后,重点就是在如何进行"滚动"以及如何用表达式控制这个滚动.

对于本题,我用的是行数以0--1--0—1的滚动方式，滚动表达式为i%2和(i-1)%2 ，没错，就是强大的求余滚动O(∩_∩)O

对于滚动数组：

1. S1[i]=S2[j]相同，dp[i][j]则继承左上方向dp[i-1][j-1]的值+1

2. 不相同dp[i][j]则继承上方與左方中的最大數值

最后整个二維陣列中最大的值，就是s1和s2的最长公共子串长度

/*
主要代码
*/
int maxlen = 0;
for(int i = 1; i <= n; i++)
{
	for (int j = 1; j <= n; j++)
	{
		//行数以0--1--0—1的滚动方式，滚动表达式为i % 2和(i - 1) % 2
		if (s1[i] == s2[j])
		{
			dp[i % 2][j] = dp[(i - 1) % 2][j - 1] + 1;
			//如果字符相等，则继承前一行前一列的dp值+1
			//也可用位运算符，更快
			//dp[i & 1][j] = dp[(i - 1) & 1][j - 1] + 1;  
		}
		else
		{
			dp[i % 2][j] = max(dp[(i - 1) % 2][j], dp[i % 2][j - 1]);
			//否则，取上方或左方的最大dp值  
			//dp[i & 1][j] = max(dp[(i - 1) & 1][j], dp[i & 1][j - 1]); 
		}
		if (max_len < dp[i % 2][j])
		{//if(dp[i & 1][j] > maxlen)
			maxlen = dp[i % 2][j];
			//maxlen = dp[i & 1][j]; 
		}
	}
}

---------------------------LCS完结---------------------------