求两个字符串的最长公共子序列

方法一、递归
采用递归的方法，代码简单，但是速度比较慢，当字符串比较大的时间，多次递归会计算一些重复的过程，因此速度很很慢。

#include<iostream>
using namespace std;

int LCSLength(int i, int j);
string x, y;
int lenx, leny;

int main()
{

    while(cin >> x >> y){
        lenx = x.length();
        leny = y.length();
        int result = LCSLength(0, 0);
        cout << result << endl; 
    }
    return 0;
}

int LCSLength(int i, int j)
{
    if(i >= lenx || j >= leny)
        return 0;
    if(x[i] == y[j])
        return 1 + LCSLength(i+1, j+1);
    else
        return LCSLength(i+1, j) > LCSLength(i, j+1) ? LCSLength(i+1, j) : LCSLength(i, j+1);
}

方法二、动态规划
可参考博客链接
http://write.blog.csdn.net/postlist
引进一个二维数组c[][]，用c[i][j]记录X[i]与Y[j] 的LCS 的长度，b[i][j]记录c[i][j]是通过哪一个子问题的值求得的，以决定搜索的方向。
我们是自底向上进行递推计算，那么在计算c[i,j]之前，c[i-1][j-1]，c[i-1][j]与c[i][j-1]均已计算出来。此时我们根据X[i] = Y[j]还是X[i] != Y[j]，就可以计算出c[i][j]。

算法分析：
由于每次调用至少向上或向左（或向上向左同时）移动一步，故最多调用(m + n)次就会遇到i = 0或j = 0的情况，此时开始返回。返回时与递归调用时方向相反，步数相同，故算法时间复杂度为Θ(m + n)。
代码实现如下：

#include <iostream>
using namespace std;

#define MAXLEN 1002

int c[MAXLEN][MAXLEN];
int LCSLength(string x, string y, int lenx, int leny, int c[][MAXLEN]);

int main()
{
    string x, y;
    while(cin >> x >> y){
        int lenx = x.length();
        int leny = y.length();

        int result = LCSLength(x, y, lenx, leny, c);
        cout << result << endl; 
    }
    return 0;
}

int LCSLength(string x, string y, int lenx, int leny, int c[][MAXLEN])
{
    int i, j;
    for(int i = 0; i <= lenx; ++i)
        c[i][0] = 0;
    for(int j = 1; j <= leny; ++j)
        c[0][j] = 0;

    for(i = 1; i <= lenx; ++i){
        for(j = 1; j <= leny; ++j){
            if(x[i-1] == y[j-1]){
                c[i][j] = c[i-1][j-1] + 1;
            }else if(c[i-1][j] >= c[i][j-1]){
                c[i][j] = c[i-1][j];
            }else{
                c[i][j] = c[i][j-1];
            }
        }
    }
    return c[lenx][leny];
}