《算法导论》学习笔记（5）——动态规划：最长子序列

        动态规划，是一种通过组合子问题的解来求解原问题的方法，应用于子问题重叠的情况，即不同的子问题具有公共的子子问题。对于这种问题，很容易想到用分治的方法，但是分治的缺点，是会做许多不必要的工作，而且会反复求解那些公共子子问题。而动态规划对每个子问题只求解一次，将其解保存在一个表格中，从而无需每次求解一个子子问题都重新计算，避免了这种不必要的计算工作。

       动态规划算法的设计通常为以下四个步骤：

       ①刻画一个最优解的结构特征

       ②递归地定义最优解的值

       ③计算最优解的值，通常采用自底向上的方法

       ④利用计算出的信息构造一个最优解

 

       下面，将根据《算法导论》的15.4节：最长公共子序列，来具体分析动态规划算法。

 

       两个序列的公共子序列指的是两个序列中相同的子序列。需要强调的是，子序列并不需要字符在字符串中是连续的。比如字符串abcdefg的一个子序列可以是ace，也可以是ceg，只要子序列中的每个字符在字符串中的位置是严格递增的即可。而最长公共子序列( longest-common-subsequenceproblem, LCS )就是求出最长的公共子序列。

 

       通过以上的定义我们可以知道最长公共子序列有如下性质：

设序列X=<x₁, x₂, …, x_m>和Y=<y₁, y₂, …, y_n>的一个最长公共子序列Z=<z₁, z₂, …, z_k>，则：

若x_m=y_n，则z_k=x_m=y_n且Z_k-1是X_m-1和Y_n-1的最长公共子序列；

若x_m≠y_n且z_k≠x_{m ，}则Z是X_m-1和Y的最长公共子序列；

若x_m≠y_n且z_k≠y_n，则Z是X和Y_n-1的最长公共子序列。

    其中X_m-1=<x₁,x₂, …, x_m-1>，Y_n-1=<y₁,y₂, …, y_n-1>，Z_k-1=<z₁,z₂, …, z_k-1>。

 

这些性质是很显然的，但是利用这些性质可以给我们带来一个很方便处理方法：我们求解当前X和Y的LCS，可以先求他们两个的子序列X'和Y'，我们可以记录下他们子序列的LCS，然后再进一步判断是否要在当前序列的LCS上添加字符。而对于他们的子序列，有可以看成是当前序列，进而就他们的子序列X''和Y''，

       于是这样就形成了递归，并且每个子问题都有重叠性质，也就是说，在计算X和Y的最长公共子序列时，可能要计算出X和Y_n-1及X_m-1和Y的最长公共子序列。而这两个子问题都包含一个公共子问题，即计算X_m-1和Y_n-1的最长公共子序列。

因此，我们就可以根据这个性质来递归地求最优解的值，假设c[i,j]记录序列_i和Y_j的最长公共子序列的长度。其中X_i=<x₁, x₂,…, x_i>，Y_j=<y₁, y₂,…, y_j>。当i=0或j=0时，空序列是X_i和Y_j的最长公共子序列，故c[i,j]=0。其他情况下，由定理可建立递归关系如下：

计算LCS的长度 LCSlength()

       该步骤需要维护两个表格（二维数组），用c[i,j]表示Xi和Yi的LCS的长度，用b[i,j]指向的表项对应计算c[i,j]时所选择的子问题最优解。

       例如X = <A,B,C,B,D,A,B>, Y = <B,D,C,A,B,A>，两张表如下：

c[2,4]表示当前的序列X' = <A,B>, Y' = <B,D,C,A>,他们的子序列的长度为1：B。

    c[4,5]表示当前的序列X' = <A,B,C,B>, Y' = <B,D,C,A,B>, 他们的子序列的长度为3：BCB。

   

构造LCS printLCS()

   根据上表，从右下角往左上角移动，只有方向为“↖”，才表示两个字符相等，就将该字符添加到当前两个字符串的子序列中。

 

实现代码如下：

#include <iostream>
using namespace std;

enum direction { UP, RIGHT, UPPERRIGHT }; //方向：上、右、右上（相等）

struct point //表格中的每一个格
{
	direction dir; //存放当前LCS的长度
	int len; //计算对应的最优解的构造过程
};

class Table
{
public:
	Table( string a, string b ); //带参数的构造函数
	~Table(); //析构函数
	void getLCS(); //返回最长子序列

private:
	string a;
	string b;
	int lengthA;
	int lengthB;
	point** p; //二维数组p，两个维度分别为字符串a和b，每个元素记录长度dir和方向len
	void LCSlength(); //构造二维数组
	void printLCS( int i, int j ); //对已经构造好的二维数组中返回最长子序列

};

Table::Table( string a, string b )
{
	this->a = a;
	this->b = b;
	lengthA = a.length();
	lengthB = b.length();
	p = new point* [lengthA+1]; //动态声明一个二维数组，每个维度长度比字符串的长度多1
	for( int i=0; i<=lengthA; i++ )
		p[i] = new point [lengthB+1];
	for( int i=1; i<lengthA+1; i++ ) //0行、0列初始化为0，
		p[i][0].len = 0;
	for( int j=0; j<lengthB+1; j++ )
		p[0][j].len = 0;
}

Table::~Table()
{
	for( int i=0; i<=lengthA; i++ )
		delete[] p[i];
	delete[] p;
}

void Table::getLCS() //先构造，再打印
{
	LCSlength();
	printLCS( lengthA, lengthB );
}

void Table::LCSlength()
{
	/*				0,					         若i=0或j=0
	 * p[i,j].len = c[i-1,j-1]+1                                 若i，j>0且x[i]==y[i]
	 * 				max(c[i,j-1],c[i-1,j]) 若i，j>0且x[i]!=y[i]
	 */
	for( int i=1; i<=lengthA; i++ )
		for( int j=1; j<=lengthB; j++ )
		{
			if( a[i-1] == b[j-1] )
			{
				p[i][j].len = p[i-1][j-1].len + 1;
				p[i][j].dir = UPPERRIGHT;
			}
			else if( p[i-1][j].len >= p[i][j-1].len )
			{
				p[i][j].len = p[i-1][j].len;
				p[i][j].dir = UP;
			}
			else
			{
				p[i][j].len = p[i][j-1].len;
				p[i][j].dir = RIGHT;
			}
		}
}

void Table::printLCS( int i, int j )
{
	if( i==0 || j==0 )
		return;
	if( p[i][j].dir == UPPERRIGHT )
	{
		printLCS( i-1, j-1 );
		cout << a[i-1] << " ";
	}
	else if( p[i][j].dir == UP )
		printLCS( i-1, j );
	else
		printLCS( i, j-1 );
}

int main() {
	string a, b;
	cin >> a >> b;
	Table table( a, b );
	table.getLCS();
	return 0;
}