从递归到动态规划（三）最长公共子序列

之前看到这种问题的时候，以为这种问题仍是挺无聊的，虽然作出来后本身会听激动的，但不少时候不知道这有什么用。今天看到《算法导论》那里提到这个用来搞两条 DNA 的比较，顿时就以为这种问题仍是挺有意思。

问题是这样的，有一个 DNA s1 是 "ACCGG" ，另外一条 DNA s2 是 "GTCGT"，求最大的公共子序列，能够不连续的。

。。。

先思考一下。

暴力遍历

首先，想到的解决方法通常都是暴力破解的。先求出全部 s1 的全部子序列，再求出 s2 的全部子序列。而后经过对比最后得到最长的公共子序列。

固然这时间复杂度也是挺感人的，假如 s1 的长度是 m，s2 的长度是 n。用相似 2 进制能够表示全部数的思想，可知求出 s1 的全部子序列的复杂读是 O(2^m)，可求出 s2 的全部子序列的复杂度是 O(2^n),而遍历对比的复杂度是 O(2^m*n)

...

这复杂度太难以接受了。。。

递归

若是是树形递归的思想呢？

树形递归的思想是这样的，假如 s1[0:i-1] 与 s2[0:j-1] 之间有一条最长的公共子序列 seq 若是 s1[i] == s2[j] ，那么最长公共子序列就是 seq + s1[i] 若是不相等，最长公共子序列就是 LCS(s1[0:i]，s2[0:j-1]) 或者是 LSC(s1[0:i-1], s2[0:j]) 中取最长。 那么是何时结束呢？应该是 i < 0 或者 j < 0 吧。

因此若是用递归很容易写出这样的代码

string lcs(string s1, string s2, int i, int j) {
  if (i < 0 || j < 0)
    return "";
  else if (s1[i] == s2[j])
    return lcs(s1, s2, i - 1, j - 1) + s1[i];
  else {
    string p1 = lcs(s1, s2, i - 1, j);
    string p2 = lcs(s1, s2, i, j - 1);
    if (p1.length() > p2.length()) {
      return p1;
    }
    return p2;
  }
}

string lcs(string s1, string s2) {
  return lcs(s1, s2, s1.length() - 1, s2.length() - 1);
}
复制代码

这固然是一如既往的有重复计算的问题的。若是用动态规划的思想。大概会是这样。

就比较容易写出这样的代码。

int lcs2(string s1, string s2) {
  int m = s1.length();
  int n = s2.length();

  vector<vector<int>> c(m + 1, vector<int>(n + 1));

  for (int i = 0; i < m + 1; i++) {
    for (int j = 0; j < n + 1; j++) {
      if (i == 0 || j == 0)
        c[i][j] = 0;
      //算法导论字符串是从1开始的，因此这里要减一
      //也方便后续的操做
      else if (s1[i - 1] == s2[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];
}
复制代码

可是这样的操做只能说求出了最长公共子序列的长度。并无将序列求出来了。 求出序列简单，按照原来的思路再遍历一次就能够了

1. 从底向上遍历 若是 s1[m-1] == s2[n-1] 就说明 c[m]][n] 是最长自序列的一个元素，不然就根据大小决定是向左仍是向上走。

string res = "";
int i = m;
int j = n;
    
while (i > 0 && j > 0) {
    if (s1[i - 1] == s2[j - 1]) {
        res = s1[i - 1] + res;
        j--;
        i--;
    } else if(c[i-1][j] > s2[i][j-1]){
        i--;
    }else {
        j--;
    }
}
return res;
复制代码

2. 自顶向下遍历。

若是 s1[i-1] == s2[j-1] 就说明最长自序列的一个元素，就 i++,j++ ，向右下角走。 不然对比右边和下边哪边打就走哪边。

string res = "";
int i = 1;
int j = 1;

while (i < m && j < n) {
    if (s1[i - 1] == s2[j - 1]) {
        res = res + s1[i - 1];
        j++;
        i++;
    } else if (c[i + 1][j] >= c[i][j + 1]) {
         i++;
    } else {
        j++;
    }
  }

 return res;
复制代码