LIS和LCS

最长上升子序列

参考博文：http://blog.youkuaiyun.com/chenwenshi/article/details/6027086

问题描述
对给定的序列，求最长上升子序列的长度。（子序列不需要连续）
例如（1，7，3，5，9，4，8），那么它的最长子序列为（1，3，5，9），其实还有其它子序列是最长的，但这里只要求长度即可，不深究（但要实现输出所有的最长子序列也不难，利用递归即可）。

解决思路
序列为num[]，对于序列的位置k，它的LIS长度就是0~k-1位置中num值小于num[k]且LIS长度最大的那个值+1。

代码

int LIS(vector<int>& nums)
{
    vector<int> maxLen;
    maxLen.resize(nums.size());
    maxLen[0]=1;
    int result = 1;
    for(int i=1; i<nums.size(); ++i)
    {
        int tmp=0;
        for(int j=0; j<i; ++j)
            if(nums[j]<nums[i] && tmp<maxLen[j])
                tmp = maxLen[j];
        maxLen[i] = tmp+1;
        if(result < maxLen[i])
            result = maxLen[i];
    }
    return result;
}

最长公共子序列

参考博文：http://blog.youkuaiyun.com/yysdsyl/article/details/4226630

问题描述
两个字符序列的最长公共字符子序列，序列不需要连续。会看这个，应该知道什么是最长公共子序列，不作详述。

解决思路
假设字符串str1[]和str2[]（假设下标从1开始），
用2个整型数组存储DP过程，

c[i][j]表示str1[i]和str2[j]的LCS，
b[i][j]表示c[i][j]是通过哪个方向求得的，0表示c[i][j]=c[i-1][j-1]+1，-1表示c[i][j] = c[i][j-1]，1表示c[i][j] = c[i-1][j]，通过b[i][j]可以确定搜索方向。
对于”BDCABA”和”ABCBDAB”，c[i][j]如下：

代码

//代码量其实不多，只是内存申请和初始化的代码比较多
string LCS(string& str1,string& str2)
{
    string result;
    if(str1.length()==0 || str1.length()==0)
        return result;
    int len1 = str1.length();
    int len2 = str2.length();
    int **c = new int*[len1+1];
    for(int i=0; i<=len1; ++i)
        c[i] = new int[len2+1];
    int **b = new int*[len1+1];
    for(int i=0; i<=len1; ++i)
        b[i] = new int[len2+1];

    for(int i=0;i<=len1; ++i)
        c[i][0] = 0;
    for(int i=0;i<=len2; ++i)
        c[0][i] = 0;
    for(int i=1; i<=len1; ++i)
    {
        for(int j=1; j<=len2; ++j)
        {
            if(str1[i-1] == str2[j-1])
            {
                c[i][j] = c[i-1][j-1]+1;
                b[i][j] = 0;
            }
            else if(c[i-1][j]>=c[i][j-1])
            {
                c[i][j] = c[i-1][j];
                b[i][j] = 1;
            }
            else
            {
                c[i][j] = c[i][j-1];
                b[i][j] = -1;
            }
        }
    }
    int i=len1, j=len2;
    while(i>0&&j>0)
    {
        if(b[i][j]==0)
        {
            result.push_back(str1[i-1]);
            --i;--j;
        }
        else if(b[i][j]==1)
            --i;
        else
            --j;
    }
    for(int i=0; i<result.length()/2; ++i)
        swap(result[i], result[result.length()-1-i]);

    for(int i=0; i<=len1; ++i)
        delete[] c[i];
    delete[] c;
    for(int i=0; i<=len1; ++i)
        delete[] b[i];
    delete[] b;
    return result;
}

最长公共子串

参考博文：http://www.cnblogs.com/ider/p/longest-common-substring-problem-optimization.html

最长公共子串和最长公共子序列简称都是LCS，前者是Longest Common Substring，后者是Longest Common Subsequent。

问题描述
两个字符串的最长公共字符子串，串是连续。

解决思路
跟最长公共子序列的问题相似，但因为子串连续的特性，所以最长公共子串求解过程中的临时解数组只与左上角的值相关。
所以，如果我们只需要求解一个满足条件的解，可以将二维数组的空间减少到2个一维数组的空间。说不清。。见代码吧。。
当然，如果要输出所有的解，那么还是需要二维数组的空间的。
代码

string LCSstr(const string& str1, const string& str2)
{
    string ret;
    if(str1.length()==0 || str2.length()==0)
        return ret;
    int len1 = str1.length();
    int len2 = str2.length();
    vector<vector<int> > table(2, vector<int>(len2, 0));
    int maxLen = 0;
    int maxi = -1;

    for(int j=0; j<len2; ++j)
    {
        table[0][j] = str1[0]==str2[j]?1:0;
        if(maxLen<table[0][j])
        {
            maxLen = table[0][j];
            maxi = 0;
        }
    }

    for(int i=1; i<len1; ++i)
    {
        int cur = i&1;
        table[cur][0] = str1[i]==str2[0]?1:0;
        if(maxLen<table[cur][0])
        {
            maxLen = table[cur][0];
            maxi = i;
        }
        for(int j=1; j<len2; ++j)
        {
            table[cur][j] = str1[i]==str2[j]?table[!cur][j-1]+1:0;
            if(maxLen<table[cur][j])
            {
                maxLen = table[cur][j];
                maxi = i;
            }
        }
    }
    int si = maxi - maxLen + 1;
    for(int i=0; i<maxLen; ++i)
        ret.push_back(str1[si+i]);
    return ret;
}