LCS（Longest Common Subsequence 最长公共子序列）

一、基本定义

LCS是Longest Common Subsequence的缩写，即最长公共子序列。一个序列，如果是两个和多个已知序列的子序列，且是所有子序列中最长的，则为最长公共子序列。

子串 ！= 子序列
子串：是连续在一起的；
子序列：子序列中的字符在字符串中不一定连续，但是子序列一定是单调的（即字符之间ASCII单调递增或单调递减）（有误！！！）

一个序列S任意删除若干个字符得到新序列T，则T叫做S的子序列；
两个序列X和Y的公共子序列中，长度最长的那个，定义为X和Y的最长公共子序列。（注意区别最长公共子串，最长公共子串要求连续）

暴力求解：穷举法，时间复杂度太大，不可取

1、假定字符串X，Y的长度分别为m,n;
2、X的一个子序列即下标序列{1,2,3…,m}的严格递增子序列，因此，X共有2^m个不同的子序列（很好理解，对与每一个元素取或不取两种情况，m个的话就死2x2x2x2….x2(m个)，即2^m个；同理Y有2^n个不同子序列，从而穷举法需要指数时间O（2^m*2^n);
3、对X的每一个子序列，检查它是否也是Y的子序列，从而确定它是否为X和Y的公共子序列，并且在检查过程中选出最长的公共子序列；
4、显然，不可取；

LCS的记号
Xi=< x1, … ,xi>即X序列的前i个字符 （1<= i <=m）(Xi不妨读作，“字符串X的i前缀”）；
Yi=< y1, … ,yj>即X序列的前j个字符 （1<= j <=m）(Yj不妨读作，“字符串Y的j前缀”）;
LCS(X,Y) 为字符串X和Y的最长公共子序列 ，即为Z= < z1, … ,zk> 。
注意：不严格的表述，事实上，X和Y可能存在多个长度相同并且最大的子串，因此，LCS（X,Y)严格的说，是个字符串集合。即：Z ->LCS (X, Y).

LCS解法的探索

若xm=yn,则有zk = xm = yn;
也即 LCS(Xm,Yn) = LCS (Xm-1, Yn-1) + xm

若xm！=yn,则有zk != xm != yn;
也即 LCS(Xm,Yn) = LCS (Xm-1, Yn) 或 LCS(Xm, Yn-1)中的最大者;

算法中的数据结构：长度数组

1、使用二维数组C[i,j]
2、c[i,j]记录序列Xi和Yj的最长公共子序列的长度，显然c[i,j] = 0;

应用实例 最长递增子序列（Longest Increasing Subsequence）
给定一个长度为N的数组，找出一个最长的单调递增子序列。
例如：给定数组{5,6,7,1,2,8}，则其最长的单调递增子序列为{5,6,7,8}，长度为4。

解题思路：将LIS问题转化为LCS问题

memset函数

#include <string.h>
void *memset( void *buffer, int ch, size_t count );
功能: 函数拷贝ch 到buffer 从头开始的count 个字符里, 并返回buffer指针。 memset() 可以应用在将一段内存初始化为某个值。
例如：
memset( the_array, '\0', sizeof(the_array) );
这是将一个数组的所以分量设置成零的很便捷的方法。

LCS代码

#include <iostream>
#include <cstring>
using namespace std;

#define MAX(a,b) (a>b?a:b)
//#define MAXN 1001
const int MAXN = 1001;
int C[MAXN][MAXN];


int main (void) {

    string X, Y;
    while(cin>>X>>Y)  {
        int m = X.length();
        int n = Y.length();

        for (int i = 1; i <= m; i++) {
            C[i][0] = 0;
        }
        for (int j = 1; j <= n; j++) {
            C[0][j] = 0;
        }

        int max = 0;
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (X[i-1] == Y[j-1]) 
                //注意公式里Xi对应这里是Xi-1，
                    C[i][j] = C[i-1][j-1] + 1;

                else 
                    C[i][j] = MAX (C[i-1][j],C[i][j-1]);
            }
        }
        cout<<C[m][n]<<endl;

    }

    return 0;
}

最长回文字符串笔试题

#include <iostream>
#include <string>
#include <algorithm>
using namespace std;

#define MAX(a,b) (a>b?a:b)

const int MAXN = 1001;
int C[MAXN][MAXN];
int LCS(string X, string Y) {
    int m = X.length();
    int n = Y.length();

    for (int i = 0; i < m; i++) {
        C[i][0] = 0;
    }
    for (int i = 0; i < n; i++) {
        C[0][i] = 0;
    }

    for (int i = 1; i <= m; i++) {
        for (int j = 1; j <= n; j++) {
            if (X[i-1] == Y[j-1]) {
                C[i][j] = C[i-1][j-1] + 1;
            }
            else {
                C[i][j] = MAX( C[i-1][j], C[i][j-1]);
            }
        }
    }
    return C[m][n];
}

int main (void) {
    string str1;
    while(cin>>str1) {
        if (str1.length() == 1){
            cout << 1 << endl;
            continue;
        }
        string str2 = str1;
        reverse(str1.begin(), str1.end());
        cout<<str1.length() - LCS(str1,str2)<<endl;
    }
    return 0;
}