最长公共子序列Lcs 51Nod - 1006 （线性dp）

给出两个字符串A B，求A与B的最长公共子序列（子序列不要求是连续的）。

比如两个串为：

abcicba

abdkscab

ab是两个串的子序列，abc也是，abca也是，其中abca是这两个字符串最长的子序列。

Input

第1行：字符串A 
第2行：字符串B 
(A,B的长度 <= 1000)

Output

输出最长的子序列，如果有多个，随意输出1个。

Sample Input

abcicba
abdkscab

Sample Output

abca

思路：

这道题是道很经典的线性dp题。做法大家应该都会，那么我这里就写下为什么用dp，如果不用dp的话，我们很明显是一个一个字符去比较，当两个字符相同时，我们在去找出之前的位置有多少个相同的字符，

这样子的复杂度是很恐怖的大概是o（2^n），但是我们仔细分析可以的发现当我们找到两个字符相同时，我们并不关心之前的相同的字符有多少，是怎么来的，我们只关心最大的值是多少，那么我们就可以当之前的最大值保存起来，然后一步一步递推过去，这样的话，复杂度就直接降为o（mn），状态转移，也容易得出来，每次影响决策的只有当前字符是否相同，如果相同的话就之前的最大值加一，如果不相同就把之前的最大值递推当前状态。

这道题其实最难得是输出这个序列，下面说下做法，我们根据之前的出来的dp值来一步一步得出这个序列。从两个字符串最后开始，为什么呢，因为这样才不会漏掉某一个解，然后还是根据是否相等来判断，当相等的时候取这个字符，如果不相等的时候，我们要移动下标，那么根据什么来移动呢，还是根据dp值来移动，如果dp[i-1][j]大于dp[i][j-1]那么明显是i--，否则j--，很容易理解的，最后倒叙输出就行了

#include<cstdio>
#include<vector>
#include<cstring>
#include<map>
#include<iostream>
#include<sstream>
#include<queue>
#include<string>
#include <cstdlib>
#include<algorithm>
#define LL long long
#define INF 0x3f3f3f3f
#include<vector>
using namespace std;
char a[5000+100];
char b[5000+100];
int dp[5000+50][5000+15];
int dp2[5000+20];
int main()
{
    while(~scanf("%s%s",a+1,b+1))
    {
        int lena = strlen(a+1);
        int lenb = strlen(b+1);
        //cout<<lena<<' ' <<lenb<<endl;
        memset(dp,0,sizeof(dp));
        for(int i = 1;i<=lena;i++)
        {
            for(int j = 1 ;j<=lenb;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]);
                }
            }
        }
        int i = lena;
        int j = lenb;
        string s = "";
        int k = 0;
        while(i!=0&&j!=0)
        {
            if(a[i]==b[j])
            {
                s+= a[i];
                i--;
                j--;
            }
            else
            {
                if(dp[i][j]==dp[i-1][j-1])
                {
                    i--;
                    j--;
                }
                 else{
                if(dp[i][j-1]>dp[i-1][j])
                {
                    j--;
                }
                else
                {
                    i--;
                }
                }
            }
        }
        reverse(s.begin(),s.end());
        cout<<s<<endl;
    }
}