最长公共子序列（LCS）动态规划的算法优化

最长公共子序列求解问题是一种典型的动态规划问题。此文章以http://nyoj.top/problem/1409   或http://acm.nyist.edu.cn/JudgeOnline/problem.php?pid=36为例说明最长子序列的动态规划算法如何优化。

关于最长公共子序列的动态规划，见https://blog.csdn.net/hrn1216/article/details/51534607

常规方法

#include<iostream>
#include<algorithm>
#include<string>//LCS（Longest Common Subsequence)
using namespace std;
int dp[1001][1001];
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	short N;
	string s1, s2;
	unsigned n1, n2,i,j;
	cin >> N;
	while (N--)
	{
		cin >> s1 >> s2;
		n1 = s1.size();
		n2 = s2.size();
		for (i = 0; i <= n1; i++)dp[i][0] = 0;
		for (j = 0; j <=n2; j++)dp[0][j] = 0;
		for(i=1;i<=n1;i++)
			for (j = 1; j <= n2; j++)
				dp[i][j] = (s1[i-1] == s2[j-1]) ? dp[i - 1][j - 1] + 1 : max(dp[i][j - 1], dp[i - 1][j]);
			cout << dp[n1][n2] << endl;
	}
	return 0;
}

注意到，此处定义了一个nxm的二维数组，空间开销很大。实际上通过观察建立的最优值的递归式

发现求解C[i,j]的值总是建立在二维数组第

i行某一列元素或者第i-1行某一列元素基础上的，如果不需要求解最长公共子序列是什么，只需要求解其长度，那么我们可以建立一个2xn的滚动数组代替nxm的数组来实现空间优化，这种方法只需要用到cur层和pre层的数据，通过cur和pre的不断交换实现mxn的数组功能。

空间优化后的代码

#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    int N,cur,pre;
    string s1,s2;
	int dp[2][1001];
    unsigned len1,len2,i,j;
    cin>>N;
    while(N--)
    {
        cin>>s1>>s2;
        len1=s1.size();
        len2=s2.size();
        cur=1;
        pre=0;
        for(i=0;i<=len2;i++)dp[0][i]=0;
        dp[1][0]=0;
        for(i=1;i<=len1;i++)
        {
            for(j=1;j<=len2;j++)
            {
                if(s1[i-1]==s2[j-1])
                    dp[cur][j]=dp[pre][j-1]+1;
                else
                    dp[cur][j]=max(dp[cur][j-1],dp[pre][j]);
            }
            swap(cur,pre);
        }
       cout<<dp[pre][len2]<<endl;
    }
    return 0;
}

此时的空间复杂度为o（n），时间复杂度还是o（nxm），此方法使用的前提是只需要求解最大公共子序列长度。

对空间继续优化

让我们在看那段代码,在横向扫描并保存数组的时候，也起到了个滑动的功能。那我们能不能只有一个纵向的数组呢？

我们在更新数组时，会发现在更新时可能需要dp[pre][j]和dp[cur][j-1] dp[pre][j-1]的值，实际上用一维数组dp[n]即可。在将要更新dp[j]前，dp[j]值即是刚才dp[pre][j]的值,dp[cur][j-1]的值对应现在dp[j-1]的值。刚才dp[pre][j-1]的值可以保存在一个临时变量old中。代码如下：

#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0); 
	int N;
	string s1, s2;
	int dp[1001],tmp,old;
	unsigned len1, len2, i, j;
	cin >> N;
	while (N--)
	{
		cin >> s1 >> s2;
		len1 = s1.size();
		len2 = s2.size();
		for (i = 0; i <= len2; i++)dp[i] = 0;
		for (i = 1; i <= len1; i++)
		{
			old = dp[0];//dp[0]代表原本dp[i-1][0]
			for (j = 1; j <= len2; j++)
			{
				tmp = dp[j];//tmp代表dp[i-1][j]的值
				if (s1[i - 1] == s2[j - 1])
					dp[j] = old + 1;//代表dp[i-1][j-1]+1
				else
					dp[j] = max(dp[j - 1], dp[j]);//dp[j-1]代表dp[i][j-1]
				//更新值后dp[j]代表dp[i][j]
				old = tmp;//保留dp[i-1][j]的值留给下一步求解最优解时使用
			}
		}
		cout << dp[len2] << endl;
	}
	return 0;
}

注：这种方法虽然能够减少一半的空间开销，但是空间复杂度仍为o(n),代码较难理解，故对空间要求不高时使用第二种方法即可。此外，对于求解LCS问题，还有一种思路是转化为最大上升子序列，并采用二分搜索，这种方法可以把平均时间复杂度降到nlogn，但是存在极端情况效率比普通的动态规划方法效率更低，且转化过程中也有一定的时间空间开销，当输入的序列中各种符号混合时构造上升子序列较麻烦，我认为一般情况下没必要去使用。