动态规划之----最长公共子序列

动态规划算法的基本要素：

1）最优子结构

      当问题的最优解包含了其子问题的最优解时，称该问题具有最优子结构性质。问题的最优子结构性质提供了该问题可用动态规划算法求解的最重要线索。

      在动态规划算法中，利用问题的最优字结构的性质，以自底向上的方式递归的从子问题的最优解逐步构造出整个问题的最优解。

2）重叠子问题

      可用动态规划算法求解的问题应具备的另一基本要素是子问题的重叠性质。在用递归算法自顶向下求解此问题时，每次产生的子问题并不总是新问题，有些子问题被反复计算多次。动态规划算法正是利用了这种子问题的重叠性质，对每个子问题只解一次，而后将其解保存在一个表格中，当再次需要解此问题时，只是简单地用常熟时间查看一下结果。

3）备忘录方法

     与动态规划算法一样，备忘录方法用表格保存已解决的子问题的答案，在下次需要解此问题时，只要简单的查看盖子问题的解答，而不需要重新计算。与动态规划算法不同的是，备忘录方法的递归方式是自顶向下的，而动态规划算法是自底向上递归的。

最长公共子序列（LCS）问题描述:

    给定两个序列，找出在两个序列中同时出现的最长子序列的长度。一个子序列是出现在相对顺序的序列，但不一定是连续的。例如，“ABC”，“ABG”，“BDF”，“AEG”，“acefg“，..等都是”ABCDEFG“ 序列。因此，长度为n的字符串有2 ^ n个不同的可能的序列。

      注意最长公共子串（Longest CommonSubstring）和最长公共子序列（LongestCommon Subsequence, LCS）的区别：子串（Substring）是串的一个连续的部分，子序列（Subsequence）则是从不改变序列的顺序，而从序列中去掉任意的元素而获得的新序列；更简略地说，前者（子串）的字符的位置必须连续，后者（子序列LCS）则不必。比如字符串acdfg同akdfc的最长公共子串为df，而他们的最长公共子序列是adf。LCS可以使用动态规划法解决。

这是一个典型的计算机科学问题，基础差异（即输出两个文件之间的差异文件比较程序），并在生物信息学有较多应用。

例子：
输入序列“ABCDGH”和“AEDFHR” 的LCS是“ADH”长度为3。
输入序列“AGGTAB”和“GXTXAYB”的LCS是“GTAB”长度为4。

这个问题的直观的解决方案是同时生成给定序列的所有子序列，找到最长匹配的子序列。此解决方案的复杂性是指数的。让我们来看看如何这个问题 （拥有动态规划（DP）问题的两个重要特性）：

1）最优子结构：
设输入序列是X [0 .. m-1]和Y [0 .. n-1]，长度分别为m和n。和设序列 L(X [0 .. m-1]，Y[0 .. n-1]）是这两个序列的LCS的长度。

以下为L（X [0 .. M-1]，Y [0 .. N-1]）的递归定义：

如果两个序列的最后一个元素匹配（即X [M-1] == Y [N-1]）
L（X [0 .. M-1]，Y [0 .. N-1]）= 1 + L（X [0 .. M-2]，Y [0 .. N-1]）

如果两个序列的最后字符不匹配（即X [M-1]！= Y [N-1]）
L（X [0 .. M-1]，Y [0 .. N-1]）= MAX（L（X [0 .. M-2]，Y [0 .. N-1]），L（X [0 .. M-1]，Y [0 .. N-2]）

例子：

1）考虑输入字符串“AGGTAB”和“GXTXAYB”。最后一个字符匹配的字符串。这样的LCS的长度可以写成：
L(“AGGTAB”, “GXTXAYB”) = 1 + L(“AGGTA”, “GXTXAY”)

2）考虑输入字符串“ABCDGH”和“AEDFHR。最后字符不为字符串相匹配。这样的LCS的长度可以写成：
L(“ABCDGH”, “AEDFHR”) = MAX ( L(“ABCDG”, “AEDFHR”), L(“ABCDGH”, “AEDFH”) )

因此，LCS问题有最优子结构性质！

2）重叠子问题：
以下是直接的递归实现，  遵循上面提到的递归结构。

/* 简单的递归实现LCS问题 */
#include<stdio.h>
#include<stdlib.h>

int max(int a, int b);

/* Returns length of LCS for X[0..m-1], Y[0..n-1] */
int lcs( char *X, char *Y, int m, int n )
{
   if (m == 0 || n == 0)
     return 0;
   if (X[m-1] == Y[n-1])
     return 1 + lcs(X, Y, m-1, n-1);
   else
     return max(lcs(X, Y, m, n-1), lcs(X, Y, m-1, n));
}

/* Utility function to get max of 2 integers */
int max(int a, int b)
{
    return (a > b)? a : b;
}

/* 测试上面的函数 */
int main()
{
  char X[] = "AGGTAB";
  char Y[] = "GXTXAYB";

  int m = strlen(X);
  int n = strlen(Y);

  printf("Length of LCS is %d\n", lcs( X, Y, m, n ) );

  getchar();
  return 0;
}

        上面直接的递归方法的时间复杂度为O（2 ^ n）.(在最坏的情况下。X和Y不匹配的所有字符即LCS的长度为0)。
按照到上述的实现，下面是对输入字符串“AXYT”和“AYZX”的部分递归树：

                         lcs("AXYT", "AYZX")
                       /                 \
         lcs("AXY", "AYZX")            lcs("AXYT", "AYZ")
         /            \                  /               \
lcs("AX", "AYZX") lcs("AXY", "AYZ")   lcs("AXY", "AYZ") lcs("AXYT", "AY")

        在上述部分递归树，LCS（“AXY”，“AYZ”）被调用两次。如果我们绘制完整的递归树，那么我们可以看到，我们可以看到很多重复的调用。所以这个问题有重叠的子结构性质，可使用memoization的或打表来避免重新计算。

       这里我们采用的是矩阵实现，也就是二维数组。

       第一步：先计算最长公共子序列的长度。

       第二步：根据长度，然后通过回溯求出最长公共子序列。

       现有两个序列X={x₁,x₂,x_3，...x_i}，Y={y₁,y₂,y_3，....，y_i}，

      设一个C[i,j]: 保存X_i与Y_j的LCS的长度。

      递推方程为：

     

下面是用动态规划(打表)解决LCS问题:

#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;

#define INF 1005
char a[INF];
char b[INF];
short c[INF][INF];

int main()
{
    int t;
    scanf("%d", &t);
    while(t--)
    {
        memset(c, 0, sizeof(c));
        scanf("%s\n%s", a+1,b+1);
        int n1 = strlen(a+1);
        int n2 = strlen(b+1);
        int m = n1>n2?n1:n2;
        for(int i=1; i<=n1; i++)
        {
            for(int j=1; j<=n2; j++)
            {
                if(a[i]==b[j]) 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];
            }
        }
        printf("%d\n", c[n1][n2]);
    }
    return 0;
}

      到这里，我们就用最经典的动态规划方式解决了这个问题。

      但是，这个解法就是最好的吗？能不能进一步优化呢？如果字符串的长度超过一万，百万，千万，十亿，一个十亿级的二维表，对空间的要求也是相当恐怖的，我们能不能优化成一维表呢？

#include <stdio.h>
#include <string.h>
char s1[1001], s2[1001];
int dp[1001], t, old, tmp;
int main(){
	scanf("%d", &t);
	while(t--){
		scanf("%s%s",s1,s2);
		memset(dp, 0, sizeof(dp));
		int lenS1=strlen(s1), lenS2=strlen(s2);
		for(int i=0; i<lenS1; i++){
			old=0;  //若s1[i]==s2[j], dp[i][j] = dp[i-1][j-1]+1
					//否则，dp[i][j] = max(dp[i-1][j], dp[i][j-1])
					//此处进行了空间优化，old 代表 dp[i-1][j-1]
					//dp[j-1] 代表 dp[i][j-1], dp[j] 代表 dp[i-1][j]
			for(int j=0; j<lenS2; j++){
				tmp = dp[j];
				if(s1[i]==s2[j]) dp[j] = old+1;
				else if(dp[j-1]>dp[j]) dp[j]=dp[j-1];
				old = tmp;
			}
		}
		printf("%d\n", dp[lenS2-1]);
	}
	return 0;
}