动态规划--最长公共子序列_最长公共子序列动态规划算法

动态规划算法思想

动态规划算法与分治法类似,其基本思想也是将待求解问题分解成若干个子问题﹐即将大规模变成小规模，先求解子问题,然后从这些子问题的解得到原问题的解。与分治法不同的是﹐适合于用动态规划法求解的问题,经分解得到的子问题往往不是互相独立的。他们之间有关系，所以用一个表来记录所有已解决的子问题的答案。不管该子问题以后是否被用到,只要它被计算过,就将其结果填人表(可以是二维，一维数组，或者是变量)中。这就是动态规划法的基本思想。

最长公共子序列

题目

给定两个序列，返回这两个序列的最长公共子序列的长度。
一个序列的子序列是指这样一个新的序列:它是由原序列在不改变字符的相对顺序的情况下删除某些字符(也可以不删除任何字符）后组成的新序列。
两个序列的公共子序列是这两个序列所共同拥有的子序列。
最长公共子序列问题:给定两个序列X={x1,x2,…xm}和Y={ y1,y2,…yn},找出X和Y的最长公共子序列。
动态规划算法可有效地解此问题。下面按照动态规划算法设计的各个 步骤设计解此问题的有效算法。

最优解结构性质

我们假设Z是X和Y的最长公共子序列,该假设的目的是使该问题的规模不断缩小
最优解结构性质

X={x1,x2,...xm}  m
Y={y1,y2,...yn}  n
Z={z1,z2,...zk}  k
1
2
3

三种情况

• xm== yn==zk
  • Zk-1=> Xm-1:Yn-1
• xm!=yn && zk!=xm
  • Zk=>Xm-1:Yn
• xm!=yn && zk!=yn
  • Zk=>Xm:Yn-1

c[i][j] =>k:
i是X序列的长度，j是Y序列的长度，c代表序列X有i个元素时，序列Y有j个元素时，最长的公共子序列的长度

注意：i不是点值，i是区域值，从1 2到i,j不是点值，j是区域值，从1 2到j

状态转移方程

分治策略的核心，规模减小到0，如果最后一个值相等，就减小一个规模，如果不相等，有一个max的概念，c[i][j]=c[i-1][j-1]+1可以写成c[i-1][j-1]=c[i][j]-1更好理解，减小规模

• i == 0 || j ==0
  • c[i][j]=0
• i>0&&j>0 x[i]==y[j]
  • c[i][j]=c[i-1][j-1]+1
• i>0&&j>0 x[i]!=y[j]
  • c[i][j]=max(c[i-1][j],c[i][j-1])

所以递归方程为

递归实现

递归实现是自顶向底，等到递归到底部的时候，即终止条件为任意一个长度为0，说明公共子序列的长度一定为0，再依次回溯，最终回溯的答案就是最长公共子序列的长度

核心函数

int sum = 0;
int LCSLength(const char* X, const char* Y, int i, int j) {
	sum += 1;
	if (i == 0 || j == 0)return 0;
	if (X[i] == Y[j]) {
		return LCSLength(X, Y, i - 1, j - 1) + 1;
	}
	else {
		int xs = LCSLength(X, Y, i - 1, j);
		int ys = LCSLength(X, Y, i, j - 1);
		if (xs >= ys)return xs;
		else return ys;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

测试

测试的话，我们求ABCBDAB和BDCABA的最长公共子序列
易知为BCBA ,该长度为4

#include<iostream>
#include<vector>
using namespace std;
int main() {
	const char* X = { "#ABCBDAB" };
	const char* Y = { "#BDCABA" };
	int xm = strlen(X) - 1;
	int yn = strlen(Y) - 1;
	int maxlen = LCSLength(X, Y, xm, yn);
	cout << maxlen << endl;
	cout << sum << endl;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

测试结果

该函数递归调用次数152，指数增长，有三个情况，一个递归函数里面嵌套了三个递归函数。比如二叉树中序遍历，每次有两个情况，一个递归函数里面嵌套了两个函数

非递归实现(画表)

递归实现是从顶部向下考虑，中间有大量的重复计算，而非递归实现即动态规划，就是从底部向上画表，画到最后，结果就出来了

核心函数

所以用填表的方法，先初始化第一行和第一列，然后一行一行的填表，根据动态规划表达式，每一个数的填写，依赖，前一个数，上一个数，左上的数字，所以每一行的填写依赖上一行
大致框架就是双层for循环，用X序列的每一个字符依次和Y序列的每一个字符

int NiceLCSLength(const char* X, const char* Y, int m, int n, vector<vector<int> >& c) {
	for (int i = 0; i <= m; i++)c[i][0] = 0;
	for (int i = 0; i <= n; i++)c[0][i] = 0;
	for (int i = 1; i <= m; i++) {
		for (int j = 1; j <= n; j++) {
			if (X[i] == Y[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];
			}
		}
	}
	return c[m][n];
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

测试

#include<iostream>
#include<vector>
using namespace std;
void PrintVector(vector<vector<int> >& c) {
	int m = c.size();
	for (int i = 0; i < m;i++) {
		for (int j = 0;j<c[i].size();j++) {
			printf("%5d", c[i][j]);
		}
		printf("\n");
	}
}
int NiceLCSLength(const char* X, const char* Y, int m, int n, vector<vector<int> >& c) {
	for (int i = 0; i <= m; i++)c[i][0] = 0;
	for (int i = 0; i <= n; i++)c[0][i] = 0;
	for (int i = 1; i <= m; i++) {
		for (int j = 1; j <= n; j++) {
			if (X[i] == Y[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];
			}
		}
	}
	return c[m][n];
}
int main() {
	const char* X = { "#ABCBDAB" };
	const char* Y = { "#BDCABA" };
	int xm = strlen(X) - 1;
	int yn = strlen(Y) - 1;
	vector<vector<int> >c(xm + 1, vector<int>(yn + 1,0));
	int maxlen = NiceLCSLength(X, Y, xm, yn,c);
	cout << maxlen << endl;
	PrintVector(c);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

测试结果

求出具体的子序列

标记方向数组

对于如何将具体的最长公共子序列求出来呢
我们再定义一个二维数组，记录2是行减一，3是列减一，1是行列都减一

int NiceLCSLength(const char* X, const char* Y, int m, int n, vector<vector<int> >& c, vector<vector<int> >& s) {
	for (int i = 0; i <= m; i++)c[i][0] = 0;
	for (int i = 0; i <= n; i++)c[0][i] = 0;
	for (int i = 1; i <= m; i++) {
		for (int j = 1; j <= n; j++) {
			if (X[i] == Y[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];
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

回溯出具体序列

当i或者j一个为0时就说明搜索结束，依次回溯序列BCBA

void LCS(int i, int j, const char* X, vector<vector<int> >& s) {
	if (i == 0 || j == 0)return;
	if (s[i][j] == 1) {
		LCS(i - 1, j - 1, X, s);
		printf("%5c", X[i]);
	}
	else if (s[i][j] == 2) {
		LCS(i - 1, j, X, s);
	}
	else {
		LCS(i, j - 1, X, s);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13