C++学习之路： 动态规划之求最长公共子序列

引言： 动态规划是我们求两个字符串最长公共子序列的重要算法，  求编辑距离时同样也要用到。

         a   b   c   d   c  b  a

     0  0   0   0  0   0  0  0

 a  0  1   1   1  1   1  1  1          

 b  0  1   2   2  2   2  2  2

 d  0  1   2   2  3   3  3  3  

 a  0  1   2   2  3   3  3  4

 c  0   1  2   3  3   4  4  4

求动态规划求最长公共子序列的原则是  当前 n-1 个序列的最长公共子是C时

 假设   abcd 

          bca  两个串最长公共子序列是c = 2 ，  

          那么 当两个串同时  加一个a

         1.abcda

         2. bcaa   显然 这时  最长公共子序列的长度是c + 1； 这个好理解，

        那么当

         1，2两串后面加的字符不一样时该怎么办，例如

         1变成 abcda

         2变成 bcab  这时该如何求公共子序列？  

         这时应该求 c[i-1][j]  和c[i][j-1],

　　　即求 1. abcda  和 bca  2. abcd 和bcab  算出1,2式的值，取最大值作为当前 abcda 和bcab 的公共子序列长。

         很好理解， 就是把 串A长度减1 求一次序列， 再把串B长度减1 再求一次序列长。

　　那么好了， 现在已经有算法了 ，我们用代码实现以下。  

  1.我们先用递归的方式先实现

　　

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

/*
* i和j表示的是字符数量
* 所以参数的含义是 A的前i个字符
* B的前j个字符
*/

//本算法用于求最长公共字序列
//递归版本随着串长的增加 复杂度成指数爆炸式增长
//最好优化为 循环版本
int LongestCommonSubsequence(const string &A,
                             const string &B,
                             int i,
                             int j)
{
    if(i == 0 || j == 0)
        return 0;

    if(A[i-1] == B[j-1]) //字符串下标操作获取字符(charl类型)
    {
        return LongestCommonSubsequence(A, B, i-1, j-1) + 1;
    }else
    {
        int t1 = LongestCommonSubsequence(A, B, i-1, j);
        int t2 = LongestCommonSubsequence(A, B, i, j-1);
        return t1 > t2 ? t1 : t2;
    }
}


int main(int argc, const char *argv[])
{
    string s1 = argv[1];
    string s2 = argv[2];
    cout << LongestCommonSubsequence(s1, s2, s1.size(), s2.size()) 
        << endl;
    return 0;
}

递归版本的逻辑在代码上十分的清楚， 但是当比较的两串 长度十分大时， 递归的效率将变得十分低下， 因为递归版本存在着大量的重复计算。

我们来说明一下， 哪里存在着重复计算， 当我们用递归版本求 A串 长6 ， B串长5时， 要把 A长度减1， B长度减一，求它们前面子串的序列， 那么每次递归都要把前面的子串都求一边， 那么计算就十分冗余。

我们比较循环和递归两个版本时， 发现效率差距是惊人的。

2. 优化递归版本， 很简单，设置一个数组，保存计算结果， 每次都判断是否已经计算过了

memo[100][100] 用于保存结果， 初始全部设置为-1； 不为-1时，即表示已经计算过

#include <iostream>
#include <string>
#include <string.h>
using namespace std;

/*
* i和j表示的是字符数量
* 所以参数的含义是 A的前i个字符
* B的前j个字符
*/

int memo[100][100]; //保存计算结果， 防止重复计算

int LongestCommonSubsequence(const string &A,
                             const string &B,
                             int i,
                             int j)
{
    if(i == 0 || j == 0)
        return 0;
    if(memo[i][j] != -1)  //如果计算过，直接返回备忘录的内容
        return memo[i][j];

    if(A[i-1] == B[j-1])
    {
        memo[i][j] = LongestCommonSubsequence(A, B, i-1, j-1) + 1;
        return memo[i][j];
    }else
    {
        int t1 = LongestCommonSubsequence(A, B, i-1, j);
        int t2 = LongestCommonSubsequence(A, B, i, j-1);
        memo[i][j] = t1 > t2 ? t1 : t2;
        return memo[i][j];
    }
}


int main(int argc, const char *argv[])
{
    string s1 = argv[1];
    string s2 = argv[2];
    memset(memo, -1, sizeof memo);
    cout << LongestCommonSubsequence(s1, s2, s1.size(), s2.size()) 
        << endl;
    return 0;
}

 3.循环版本也十分简单， 利用我们手算的逻辑既可以实现。

#include <iostream>
#include <string>
#include <string.h>

#include <queue>
#include <algorithm>

using namespace std;

inline int MAX(int a, int b) {
        return a > b ? a : b;
}

int memo[100][100]; //暂存结果的集合

int LongestCommonSequence(const string &a, const string &b, int i, int j) {
        if (i == 0 || j == 0) {
                return 0;
        }

        if (memo[i][j] == -1) {        //缓存中没有结果，需要自己计算

                if (a[i - 1] == b[j - 1]) {
                        return LongestCommonSequence(a, b, i - 1, j - 1) + 1;
                }

                return MAX(LongestCommonSequence(a, b, i, j - 1),
                                LongestCommonSequence(a, b, i - 1, j));
        } else {        //直接返回结果
                return memo[i][j];
        }
}

int LCS(const string &a, const string &b) {
        int memo[100][100];        //暂存结果

        // memo[i][0] = 0
        for (int i = 0; i <= a.size(); ++i) {
                memo[i][0] = 0;
        }
        for (int j = 0; j <= b.size(); ++j) {
                memo[0][j] = 0;
        }

        for (int i = 1; i <= a.size(); ++i) {
                for (int j = 1; j <= b.size(); ++j) {
                        if (a[i - 1] == b[j - 1]) {
                                memo[i][j] = memo[i - 1][j - 1] + 1;
                        } else {
                                memo[i][j] = MAX(memo[i - 1][j], memo[i][j - 1]);
                        }
                }
        }

        return memo[a.size()][b.size()];

}
int main(int argc, char **argv) {
//        memset(memo, 0xff, 100 * 100 * sizeof(int));
//
//        string a = "abcbdab";
//        string b = "bdcaba";
//        int ret = LongestCommonSequence(a, b, a.size(), b.size());
//
//        cout << ret << endl;
//
//        ret = LCS(a, b);
//        cout << ret << endl;


//        priority_queue<int, vector<int>, less<int> > q;
//
//        q.push(13);
//        q.push(23);
//
//        cout << q.top() << endl;



        //建立一个大根堆
        priority_queue<Student, vector<Student>, compare > q;

        q.push(Student(1, "hello"));
        q.push(Student(12, "test"));
        q.push(Student(9, "test"));

        Student tmp = q.top();

        cout << tmp._id << endl;

        //其他方式
        //priority_queue<Student, vector<Student>, less<Student> > q;
        //这种需要重载Student的<操作符

}