动态规划最长公共子序列

动态规划

动态规划算法通常用于求解具有某种最优性质的问题。我对动态规划的理解还比较浅显，目前认为动态有这几个特点：

1.把原问题分解为子问题，这个有点像分治法，但与分治法不同的是，动态规划里上一级问题的求解依赖于下一级问题的解答，而在分治法里，如归并排序，即使下一子集没有排好序，上一级代码也可以得到执行（不过答案就不对了）。
2.动态规划存在重复计算的子问题，一般为了避免重复计算而不会用递归。
3.动态规划将未知转化成已知。

最长公共子序列

子序列： 一个序列A ＝ a1,a2,……an,中任意删除若干项，剩余的序列叫做A的一个子序列。也可以认为是从序列A按原顺序保留任意若干项得到的序列。

最长公共子序列（longest common sequence）和最长公共子串（longest common substring）不是一回事儿。

公共子序列 ： 顾名思义，如果序列C既是序列A的子序列，同时也是序列B的子序列，则称它为序列A和序列B的公共子序列。

最长公共子序列：A和B的公共子序列中长度最长的（包含元素最多的）叫做A和B的公共子序列。

分析：

#include"stdafx.h"
#include <iostream>
#include <cstring>
using namespace std;
const int N = 1024;
int c[N][N], b[N][N];
char s1[] = "abcdefg", s2[] = "bcdagh";
int len1, len2;
void LCS()
{
	for (int i = 0; i <= len1; i++){
		c[i][0] = 0;
	}
	for (int j = 0; j <= len2; j++){
		c[0][j] = 0;
	}
	for (int i = 1; i <= len1; i++){
		for (int j = 1; j <= len2; j++){
			if (s1[i - 1] == s2[j - 1]){ //注：此处的s1与s2序列是从s1[0]与s2[0]开始的
				c[i][j] = c[i - 1][j - 1] + 1;
				b[i][j] = 1;
			}
			else{
				if (c[i][j - 1] >= c[i - 1][j]){
					c[i][j] = c[i][j - 1];
					b[i][j] = 2;
				}
				else{
					c[i][j] = c[i - 1][j];
					b[i][j] = 3;
				}
			}
		}
	}
}

void LCS_PRINT(int i, int j)
{
	if (i == 0 || j == 0){
		return;
	}
	if (b[i][j] == 1){
		LCS_PRINT(i - 1, j - 1);
		cout << s1[i - 1];
	}
	else if (b[i][j] == 2){
		LCS_PRINT(i, j - 1);
	}
	else{
		LCS_PRINT(i - 1, j);
	}
}

int main()
{

	len1 = strlen(s1);
	len2 = strlen(s2);
	LCS();
	cout << "s1与s2的最长公共子序列的长度是：" << c[len1][len2] << endl;
	cout << "s1与s2的最长公共子序列是：";
	LCS_PRINT(len1, len2);

	cout << endl;
	for (int i = 0; i <= len1; i++)
	{
		for (int j = 0; j <= len2; j++)
		{
			cout << c[i][j] << "  ";
		}
		cout << endl;
	}
	cout << "__________________" << endl;
	for (int i = 0; i <= len1; i++)
	{
		for (int j = 0; j <= len2; j++)
		{
			cout << b[i][j] << "  ";
		}
		cout << endl;
	}

	system("pause");
	return 0;
}