大二（下）算法与设计 动态规划法

内容：用动态规划法实现求两序列的最长公共子序列。
要求：掌握动态规划法的思想，及动态规划法在实际中的应用；分析最长公共子序列的问题特征，选择算法策略并设计具体算法，编程实现两输入序列的比较，并输出它们的最长公共子序列。

#include <iostream>
#include <string>
using namespace std;
int const MaxLen = 50;
class LCS
{
public:
	LCS(int nx, int ny, char *x, char *y)
	{
		m = nx;
		n = ny;
		a = new char[m + 2];
		b = new char[n + 2];
		memset(a, 0, sizeof(a));  //将某一块内存中的内容全部设置为指定的值， 
memset(b, 0, sizeof(b));  //通常为新申请的内存做初始化工作
		for (int i = 0; i < nx + 2; i++)
			a[i + 1] = x[i];
		for (int i = 0; i < ny + 2; i++)
			b[i + 1] = y[i];
		c = new int[MaxLen][MaxLen];
		s = new int[MaxLen][MaxLen];
		memset(c, 0, sizeof(c));
		memset(s, 0, sizeof(s));
	}

	int LCSLength();

	void CLCS()
	{
		CLCS(m, n);
	}

private:
	void CLCS(int i, int j);
	int(*c)[MaxLen], (*s)[MaxLen];
	int m, n;
	char *a, *b;
};

int LCS::LCSLength()   //时间复杂度：O(m×n)
{
	for (int i = 1; i <= m; i++)
		c[i][0] = 0;
	for (int j = 1; j <= n; j++)
		c[0][j] = 0;
	for (int i = 1; i <= m; i++)
	{
		for (int j = 1; j <= n; j++)
		{
			if (a[i] == b[j])
			{
				c[i][j] = c[i - 1][j - 1] + 1;
				s[i][j] = 1;
			}
			else if (c[i - 1][j] >= c[i][j - 1])
			{
				c[i][j] = c[i - 1][j];
				s[i][j] = 2;
			}
			else
			{
				c[i][j] = c[i][j - 1];
				s[i][j] = 3;
			}
		}
	}
	return c[m][n];
}

void LCS::CLCS(int i, int j)   
{
	if (i == 0 || j == 0)
		return;
	if (s[i][j] == 1)
	{
		CLCS(i - 1, j - 1);
		cout << a[i];
	}
	else if (s[i][j] == 2)
		CLCS(i - 1, j);
	else
		CLCS(i, j - 1);
}

int main()
{
	int nx, ny;
	char *x = new char[MaxLen], *y = new char[MaxLen];
	cout << "请输入原序列 (不含空格)" << endl;
	cin>>x;
	nx = strlen(x);
	cout << "请输入公共序列 (不含空格)" << endl;
	cin >> y;
	ny = strlen(y);
	LCS lcs(nx, ny, x, y);
	cout << "X和Y最长公共子序列的长度为：" << lcs.LCSLength() << endl;
	cout << "该序列为" << endl;
	lcs.CLCS();
	cout << endl;
	delete[]x;
	delete[]y;
	return 0;
}

1.对于线性规划求最长公共字序列的优化：
备忘录方法是动态规划法的一个变种，它采用分治法思想，自顶向下直接递归求最优解。但与分治法不同的是，备忘录方法为每个已经计算的子问题建立备忘录，即保存子问题的计算结果以备需要时应用，从而避免子问题的重复求解。改写当前的int LCSLength()函数，用备忘录方法来求解最长公共子序列。

int LCS::LCSLength(int i, int j)
{
	if (i == 0 || j == 0)
		return 0;
	if (c[i][j] != 0)
		return c[i][j];
	else
	{
		if (a[i] == b[j])
		{
			c[i][j] + LCSLength(i - 1, j - 1) + 1;
			s[i][j] = 1;
		}
		else if (LCSLength(i - 1, j) >= LCSLength(i, j - 1))
		{
			c[i][j] = LCSLength(i - 1, j);
			s[i][j] = 2;
		}
		else
		{
			c[i][j] = LCSLength(i, j - 1);
			s[i][j] = 3;
		}
	}
	return c[i][j];
}

2. 请编写一个类似的CLCS算法实现。不借助二维数组s在O(m+n)的时间内构造最长公共子序列的功能。

void LCS::CLCS(int i, int j)
{
	if (i == 0 || j == 0)
		return;
	if (a[i] == b[j])
	{
		CLCS(i - 1, j - 1);
		cout << a[i];
	}
	else
	{
		if (c[i - 1][j] >= c[i][j - 1])
			CLCS(i - 1, j);
		else
			CLCS(i, j - 1);
	}
}

3.如果只需计算最长公共子序列的长度，而无须构造最优解，则如何改进原有程序可以使得算法的空间需求大大减少？
请改写原程序，使算法的空间复杂度减少为O(min{m,n})。

#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
#define MAX 50
class LCS
{
public:
	LCS(int nx, int ny, char *x, char *y)
	{
		m = nx;
		n = ny;
		a = new char[m + 1];
		b = new char[n + 1];
		memset(a, 0, sizeof(a));
		memset(b, 0, sizeof(b));
		for (int i = 0; i < nx; i++)
			a[i + 1] = x[i];
		for (int i = 0; i < ny; i++)
			b[i + 1] = y[i];
		if (m > n)
		{
			l = m;
			s = n;
		}
		else
		{
			char *t;
			swap(x, y);
			s = m;
			l = n;
		}
		c1 = new int[s + 1];
		c2 = new int[s + 1];
		memset(c1, 0, sizeof(c1));
		memset(c2, 0, sizeof(c2));
	}
	int LCSLength();
private:
	int m, n;
	int *c1, *c2;
	int l, s;
	char *a, *b;
};

int LCS::LCSLength()
{
	for (int i = 0; i < s; i++)
		c1[i] = 0;
	for (int i = 1; i <= l; i++)
	{
		for (int j = 1; j <= s; j++)
		{
			if (a[i] == b[j])
				c2[j] = c1[j - 1] + 1;
			else if (c1[j] >= c2[j - 1])
				c2[j] = c1[j];
			else
				c2[j] = c2[j - 1];
		}
		for (int j = 0; j < s; j++)
			c1[j] = c2[j];
	}
	return c2[s];
}

int main()
{
	int nx, ny;
	char *x, *y;
	x = new char[MAX];
	y = new char[MAX];
	cout << "请输入X (不含空格)" << endl;
	cin >> x;
	nx = strlen(x);
	cout << "请输入Y (不含空格)" << endl;
	cin >> y;
	ny = strlen(y);
	LCS lcs(nx, ny, x, y);
	cout << "X和Y最长公共子序列的长度为：" << lcs.LCSLength() << endl;
	delete[]x;
	delete[]y;
	return 0;
}