最长公共子序列(LCS)

先介绍LCS问题的性质：记Xm={x0, x1,…xm-1}和Yn={y0,y1,…,yn-1}为两个字符串，而Zk={z0,z1,…zk-1}是它们的LCS，则：
1.    如果xm-1=yn-1，那么zk-1=xm-1=yn-1，并且Zk-1是Xm-1和Yn-1的LCS；
2.    如果xm-1≠yn-1，那么当zk-1≠xm-1时Z是Xm-1和Y的LCS；
3.    如果xm-1≠yn-1，那么当zk-1≠yn-1时Z是Yn-1和X的LCS；
下面简单证明一下这些性质：
1.    如果zk-1≠xm-1，那么我们可以把xm-1（yn-1）加到Z中得到Z’，这样就得到X和Y的一个长度为k+1的公共子串Z’。这就与长度为k的Z是X和Y的LCS相矛盾了。因此一定有zk-1=xm-1=yn-1。
既然zk-1=xm-1=yn-1，那如果我们删除zk-1（xm-1、yn-1）得到的Zk-1，Xm-1和Yn-1，显然Zk-1是Xm-1和Yn-1的一个公共子串，现在我们证明Zk-1是Xm-1和Yn-1的LCS。用反证法不难证明。假设有Xm-1和Yn-1有一个长度超过k-1的公共子串W，那么我们把加到W中得到W’，那W’就是X和Y的公共子串，并且长度超过k，这就和已知条件相矛盾了。
2.    还是用反证法证明。假设Z不是Xm-1和Y的LCS，则存在一个长度超过k的W是Xm-1和Y的LCS，那W肯定也X和Y的公共子串，而已知条件中X和Y的公共子串的最大长度为k。矛盾。
3.    证明同2。
有了上面的性质，我们可以得出如下的思路：求两字符串Xm={x0,x1,…xm-1}和Yn={y0,y1,…,yn-1}的LCS，如果xm-1=yn-1，那么只需求得Xm-1和Yn-1的LCS，并在其后添加xm-1（yn-1）即可；如果xm-1≠yn-1，我们分别求得Xm-1和Y的LCS和Yn-1和X的LCS，并且这两个LCS中较长的一个为X和Y的LCS。
如果我们记字符串Xi和Yj的LCS的长度为c[i,j]，我们可以递归地求c[i,j]：
       /    0                     if i<0 or j<0
c[i,j]=       c[i-1,j-1]+1              ifi,j>=0 and xi=xj
      \     max(c[i,j-1],c[i-1,j]        ifi,j>=0 and xi≠xj

上面的公式用递归函数不难求得。

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

// directions of LCS generation
enum decreaseDir
{
	kInit = 0, kLeft, kUp, kLeftUp
};
void LCS_Print(int **LCS_direction, char* pStr1, char* pStr2, size_t row,
		size_t col);
/////////////////////////////////////////////////////////////////////////////
// Get the length of two strings' LCSs, and print one of the LCSs
// Input: pStr1         - the first string
//        pStr2         - the second string
// Output: the length of two strings' LCSs
/////////////////////////////////////////////////////////////////////////////
int LCS(char* pStr1, char* pStr2)
{
	if (!pStr1 || !pStr2)
		return 0;

	size_t length1 = strlen(pStr1);
	size_t length2 = strlen(pStr2);
	if (!length1 || !length2)
		return 0;

	size_t i, j;

	// initiate the length matrix
	int **LCS_length;
	LCS_length = (int**) (new int[length1]);
	for (i = 0; i < length1; ++i)
		LCS_length[i] = (int*) new int[length2];

	for (i = 0; i < length1; ++i)
		for (j = 0; j < length2; ++j)
			LCS_length[i][j] = 0;

	// initiate the direction matrix
	int **LCS_direction;
	LCS_direction = (int**) (new int[length1]);
	for (i = 0; i < length1; ++i)
		LCS_direction[i] = (int*) new int[length2];

	for (i = 0; i < length1; ++i)
		for (j = 0; j < length2; ++j)
			LCS_direction[i][j] = kInit;

	for (i = 0; i < length1; ++i)
	{
		for (j = 0; j < length2; ++j)
		{
			if (i == 0 || j == 0)
			{
				if (pStr1[i] == pStr2[j])
				{
					LCS_length[i][j] = 1;
					LCS_direction[i][j] = kLeftUp;
				}
				else
					LCS_length[i][j] = 0;
			}
			// a char of LCS is found,
			// it comes from the left up entry in the direction matrix
			else if (pStr1[i] == pStr2[j])
			{
				LCS_length[i][j] = LCS_length[i - 1][j - 1] + 1;
				LCS_direction[i][j] = kLeftUp;
			}
			// it comes from the up entry in the direction matrix
			else if (LCS_length[i - 1][j] > LCS_length[i][j - 1])
			{
				LCS_length[i][j] = LCS_length[i - 1][j];
				LCS_direction[i][j] = kUp;
			}
			// it comes from the left entry in the direction matrix
			else
			{
				LCS_length[i][j] = LCS_length[i][j - 1];
				LCS_direction[i][j] = kLeft;
			}
		}
	}
	LCS_Print(LCS_direction, pStr1, pStr2, length1 - 1, length2 - 1);
	/*for (i = 0; i < length1; i++)
	{
		printf("\n");
		for (j = 0; j < length2; j++)
		{
			printf("%d%s\t", LCS_length[i][j],
					(LCS_direction[i][j] == kUp ?
							"↑" :	(LCS_direction[i][j] == kLeft ?	"←" :
									(LCS_direction[i][j] == kLeftUp ? "↖" : " "))));
		}
	}*/
	int len = LCS_length[length1 - 1][length2 - 1];
	for (i = 0; i < length1; ++i)
		delete[] LCS_length[i];
	delete[] LCS_length;
	return len;
}

/////////////////////////////////////////////////////////////////////////////
// Print a LCS for two strings
// Input: LCS_direction - a 2d matrix which records the direction of
//                        LCS generation
//        pStr1         - the first string
//        pStr2         - the second string
//        row           - the row index in the matrix LCS_direction
//        col           - the column index in the matrix LCS_direction
/////////////////////////////////////////////////////////////////////////////
void LCS_Print(int **LCS_direction, char* pStr1, char* pStr2, size_t row,
		size_t col)
{
	if (pStr1 == NULL || pStr2 == NULL)
		return;

	size_t length1 = strlen(pStr1);
	size_t length2 = strlen(pStr2);

	if (length1 == 0 || length2 == 0 || !(row < length1 && col < length2))
		return;

	// kLeftUp implies a char in the LCS is found
	if (LCS_direction[row][col] == kLeftUp)
	{
		if (row > 0 && col > 0)
			LCS_Print(LCS_direction, pStr1, pStr2, row - 1, col - 1);

		// print the char
		printf("%c", pStr1[row]);
	}
	else if (LCS_direction[row][col] == kLeft)
	{
		// move to the left entry in the direction matrix
		if (col > 0)
			LCS_Print(LCS_direction, pStr1, pStr2, row, col - 1);
	}
	else if (LCS_direction[row][col] == kUp)
	{
		// move to the up entry in the direction matrix
		if (row > 0)
			LCS_Print(LCS_direction, pStr1, pStr2, row - 1, col);
	}
}

int main(void)
{
	LCS("ABCBDAB", "BDCABA");//结果：BDAB
	return 0;
}