动态规划之最长公共子序列（LCS）

题目描述：

动态规划实现

输入输出：

n， m表示A，B字符串的长度

char A[N], B[N]存A，B字符串

输出：

dp[n][m]

dp[i][j]表示A的长度为i， B的长度为j时，LCS的值。

我们可以用dp[i][j]递归定义，然后自底向上求解dp[n][m],即长度为n的A与长度为m的B的LCS。

思路：

1.刻画最优子结构

2.递归（自顶向下）定义最优值：

我们用LCS（i ，j ）表示A的长度为i， B的长度为j时的LCS
最重要的一步

本题中，考虑A数组长度为i，B数组长度为j的情况时，

如果A[i] = B[j],那么问题可以规约成求LCS（i -1， j -1），有

LCS（i， j） = LCS(i - 1, j - 1) + 1

如果A[i] != B[j], 那么LCS(i, j) 可以规约为求LCS（i, j - 1)和LCS（i - 1， j）的最大值

LCS(i, j) = max(LCS(i - 1, j), LCS(i, j -1))

    for (int i = 1; i <= n; i ++)
        for (int j = 1; j <= m; j ++)
            {
                if (a[i] == b[j]) dp[i][j] = dp[i - 1][j - 1] + 1;
                else dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
            }

3.自底向上迭代计算最优值：

这一步需要注意初始化条件，比如在本题中，我们需要初始化dp数组，

for (int i = 1; i <= m; i ++)   dp[0][m] = 0;
for (int i = 1; i <= n; i ++)   dp[n][0] = 0;

代表A的长度为0，B的长度为0到m时，LCS为0；

A的长度为0到n时，B的长度为0时，LCS为0；

4.构造最优解（一般就是我们计算得到的）

在本题中最优解就是LCS的长度，即LCS（n， m）但如果需要给出公共子序列，那么就需要额外构造最优解。

本题代码：

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 1010;

char a[N], b[N];
int n, m;
int dp[N][N];

int main()
{
    cin >> n >> m >> a + 1 >> b + 1;
    
    for (int i = 1; i <= m; i ++)   dp[0][m] = 0;
    for (int i = 1; i <= n; i ++)   dp[n][0] = 0;
    
    for (int i = 1; i <= n; i ++)
        for (int j = 1; j <= m; j ++)
            {
                if (a[i] == b[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][m];
    
    return 0;
}