LCS

思路：

　　明显的可以想到，状态转移方程为：

　　当x[i] == y[j]时，dp[i][j] = dp[i-1][j-1]+1

　　当x[i] != y[j]时，dp[i][j] = max(dp[i-1][j], dp[i][j-1])

　　这种方法可以结合下面的决策矩阵和代码加深理解（参考自https://blog.csdn.net/linraise/article/details/9104975

　　

#include<iostream>
using namespace std;
#define M 7
#define N 6
int b[M + 1][N + 1] = {0}; //存方向
int c[M + 1][N + 1] = {0}; //存值

void Lcs_Length(char *X, char *Y)
{
    int i, j;
    for(i = 1; i <= M; i++)
        c[i][0] = 0;
    for(j = 0; j <= N; j++)
        c[0][j] = 0;
    for(i = 1; i <= M; i++)
    {
        for(j = 1; j <= N; j++)
        {
            if(X[i] == Y[j]) //比较两个字串对应位，如果相等，则=对角+1
            {
                c[i][j] = c[i - 1][j - 1] + 1;
                b[i][j] = 1; //1代表↖　
            }
            else if(c[i - 1][j] >= c[i][j - 1]) //如果上面值>=下面值
            {
                c[i][j] = c[i - 1][j]; //c[i][j]=大值
                b[i][j] = 2; //2代表↑
            }
            else
            {
                c[i][j] = c[i][j - 1]; //赋的总是大值，箭头总是指向大值
                b[i][j] = 3; //3代表←
            }
        }
    }
}
void Print_Lcs(char *X, int i, int j)
{
    if(i == 0 || j == 0)
        return ;
    if(b[i][j] == 1)
    {
        Print_Lcs(X, i - 1, j - 1);
        cout << X[i] << ' '; //只需输出↖对应的值
    }
    else if(b[i][j] == 2)
        Print_Lcs(X, i - 1, j);
    else Print_Lcs(X, i, j - 1);
}
int main()
{
    char  X[M + 1] = {'0', 'A', 'B', 'C', 'B', 'D', 'A', 'B'};
    char  Y[N + 1] = {'0', 'B', 'D', 'C', 'A', 'B', 'A'};
    Lcs_Length(X, Y);
    Print_Lcs(X, M, N);
    cout << endl;
    for(int i = 0; i <= M; i++)
    {
        for(int j = 0; j <= N; j++)
        {
            cout << c[i][j] << ' ';
        }
        cout << endl;
    }
    cout << endl;
    for(int i = 0; i <= M; i++)
    {
        for(int j = 0; j <= N; j++)
        {
            switch(b[i][j])
            {
            case 0:
            {
                cout << b[i][j] << "  ";
                break;
            }
            case 1:
            {
                cout << '\' << ' ' << ' ';
                break;
            }
            case 2:
            {
                cout << '|' << ' ' << ' ';
                break;
            }
            case 3:
            {
                cout << '-' << ' ' << ' ';
                break;
            }
            }
        }
        cout << endl;
    }
    return 0;
}

 

进一步分析：

　　这种动态规划做法，用空间换取时间，对比暴力法，时间复杂度由O(m²n²)降低到了O(n²)，那么有没有什么方法能进一步优化空间复杂度呢？答案是肯定的。分析上面的决策矩阵，发现每一行的值都是由上一行决定的，所以前面行的值是可以舍弃，不必保存的，这就可以使用滚动数组进行空间优化。

for(i = 1; i <= m; i++)
{
    for(j = 1; j <= n; j++)
    {
        if(x[i] == y[j])
            dp[i % 2][j] = dp[(i - 1) % 2][j - 1] + 1;
        else if(dp[(i - 1) % 2][j] >= dp[i % 2][j - 1])
            dp[i % 2][j] = dp[(i - 1) % 2][j];
        else
            dp[i % 2][j] = dp[i % 2][j - 1];
    }
}

 　　那么O(n²)的时间复杂度能继续优化吗？答案也是肯定的。做法是将LCS问题转换成O(nlogn)的LIS问题来求解，后续补充~

 reference：

https://blog.csdn.net/linraise/article/details/9104975