2. 程式人生 > >使用動態規劃解決最長公共子序列問題

使用動態規劃解決最長公共子序列問題

阿新 • • 發佈：2019-01-26

一、定義：

給定兩個序列X和Y，如果Z既是X的子序列也是Y的子序列，那麼我們稱Z是X和Y的公共子序列。例如：X={a,b,c,e,d,g,f}，Y={b,e,f,g},那麼Z={b}、Z={b,e}、Z={b,e,f}都是X和Y的公共子序列，其中Z={b，e，f}是X和Y的最長公共子序列。求解X和Y的最長公共子序列就是LCS問題。最長公共子序列不唯一，但是其長度是唯一的。

二、定理：

令X={x1,x2,...,xm}和Y={y1,y2,....yn}為兩個序列，Z={z1,z2,...zk}為這兩個序列的最長公共子序列，則：

①如果xm=yn,那麼zk = xm = yn，且Z(k-1)是X(m-1)和Y(n-1)的一個最長公共子序列；

②如果xm != yn，zk != xm，那麼Z(k-1)是X(m-1)和Yn的一個最長公共子序列；

③如果xm != yn，zk != yn，那麼Z(k-1)是Xm和Y(n-1)的一個最長公共子序列；

這樣我們在求解X和Y的LCS時，可以分解為求解一個或兩個這樣的子問題。當xm = yn，我們需要求解X(m-1)和Y(n-1)的LCS；當xm != yn時，我們需要求解X(m-1)和Yn的一個LCS，以及求解Xm和Y(n-1)的一個LCS，兩個較長者既為X和Y的LCS。

三、求解步驟：

如果用暴力搜尋法求解LCS問題，就要窮舉X的所有子序列，對於每個子序列都要檢查它是否也是Y的子序列，從而找到最長子序列。X的每個子序列對應下表集合{1,2,3，....，m}，所以X有2^m個子序列，因此暴力搜尋法的執行時間為指數階，對較長的序列是不適用的，但是根據以上定理，LCS問題具有最優子結構性質。

我們定義一個二維陣列c[i][j]用來記錄Xi和Yj的LCS的長度。如果i=0，或者j=0，既一個序列長度為0，那麼LCS的長度為0。根據最優子結構性質，可得如下公式

  

上述公式適用於字串下標為0時儲存的是字串的長度，然而我們常見的字串是'\0'為結尾的，下標為0的內容儲存的並不是字串的長度，因此我們把公式稍作修改以適應解決我們常見的字串


根據以上公式我們，可以用動態規劃方法自頂向上地計算c[i][j]的值。

以下為計算c[i][j]的值，並給出測試程式：

#include <iostream>
#define MAX_LEN 100
using namespace std;
/*給定兩個字串X和Y，求出Xi和Yj的最長公共子序列的長度，記錄在c[i][j]陣列中*/
void get_lcslength(const char X[],int Xlen, const char Y[],int Ylen, int c[][MAX_LEN]);

int main()
{
	
	char X[] = "abaddc";
	char Y[] = "badcaef";

	int m = strlen(X);
	int n = strlen(Y);
	int c[MAX_LEN][MAX_LEN];

	get_lcslength(X, m, Y, n, c);
	for (int i = 0; i < m;i++)
	{
		for (int j = 0; j < n;j++)
		{
			cout << c[i][j] <<"	";
		}
		cout << endl;
	}
	return 0;
}
<pre name="code" class="cpp">void get_lcslength(const char X[],int Xlen, const char Y[],int Ylen, int c[][MAX_LEN])
{
	int i = 0, j = 0;
	/*初始化第0行，如果X[0]=Y[i]，則說明LCS的長度為1*/
	while (i < Ylen && X[0] != Y[i])
	{
		c[0][i] = 0;
		i++;
	}

	for (; i < Ylen; i++)
		c[0][i] = 1;
	/*同理，初始化第0列*/
	while (j < Xlen && Y[0] != X[j])
	{
		c[j][0] = 0;
		j++;
	}

	for (; j < Xlen; j++)
		c[j][0] = 1;

	for (i = 1; i < Xlen;i++)
	{
		for (j = 1; j < Ylen;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];
		}
	}
}

程式的執行結果如下：

我們一張表格來解釋上面的程式：

第i行和第j列記錄了c[i][j]的值，對於第0行第0列X[0] != Y[0]，故c[0][0]=0,對於第0行第1列，X[0]=Y[1]，因此c[0][1]=1，那麼第0行從第1列開始及以後的列都為1；同理可求出第0列的所有c[i][0]的值。對於i>0，j>0的，標項c[i][j]的值取決於X[i]是否等於Y[j]及c[i-1][j-1]、c[i-1][j]、c[i][j-1]的值，這些值都會在計算c[i][j]的值之前計算出來。c[5][6]記錄了X和Y的LCS的長度。

當我們求出二維陣列c的值之後，我們可以根據這個二維陣列求解LCS，通過上述分析我們可以瞭解到：c[i][j]的值只取決於c[i-1][j-1]、c[i-1][j]、c[i][j-1]這三項，給出c[i][j]的值我們可以在O(1)時間內判斷出計算c[i][j]的值使用了這三項中的哪一項，我們配合下面的圖說明一下演算法的實現原理：

圖中的箭頭表示當計算c[i][j]時所使用的上一個元素是誰，首先c[i][j]與c[i][j-1]作比較，如果相等則表明計算c[i][j]時使用的是c[i][j-1]，此時令j=j-1；否則，c[i][j]與c[i-1][j]作比較，如果相等則表明計算c[i][j]時使用的是c[i-1][j]，此時令i=i-1；否則表明計算c[i][j]時使用的是c[i-1][j-1]，那麼這時X[i] == Y[j]，將這個相等的字元記錄到str陣列中，並令j=j-1，i=i-1。進行迴圈比較直到i、j有一個出現0時為止。程式碼如下：

#include <iostream>
#define MAX_LEN 100
using namespace std;
/*給定兩個字串X和Y，求出Xi和Yj的最長公共子序列的長度，記錄在c[i][j]陣列中*/
void get_lcslength(const char X[],int Xlen, const char Y[],int Ylen, int c[][MAX_LEN]);
/*給定兩個字串X和Y，將最長公共子序列儲存在str陣列中*/
char *lcs(const char X[], const char Y[], char str[]);
int main()
{
	
	char X[] = "abaddc";
	char Y[] = "badcaef";
	char str[MAX_LEN];
	lcs(X, Y, str);
	cout << "最長公共子序列為：" << str << "	長度為：" << strlen(str)<<endl;
	lcs("acbecda", "abcdaef", str);
	cout << "最長公共子序列為：" << str << "	長度為：" << strlen(str) << endl;
	lcs("gcbecda", "hbcdaef", str);
	cout << "最長公共子序列為：" << str << "	長度為：" << strlen(str) << endl;
	lcs("ghijklmna", "hbcdaef", str);
	cout << "最長公共子序列為：" << str << "	長度為：" << strlen(str) << endl;
	lcs("gijklmn", "hbcdaef", str);
	cout << "最長公共子序列為：" << str << "	長度為：" << strlen(str) << endl;
	return 0;
}

void get_lcslength(const char X[],int Xlen, const char Y[],int Ylen, int c[][MAX_LEN])
{
	int i = 0, j = 0;
	/*初始化第0行，如果X[0]=Y[i]，則說明LCS的長度為1*/
	while (i < Ylen && X[0] != Y[i])
	{
		c[0][i] = 0;
		i++;
	}

	for (; i < Ylen; i++)
		c[0][i] = 1;
	/*同理，初始化第0列*/
	while (j < Xlen && Y[0] != X[j])
	{
		c[j][0] = 0;
		j++;
	}

	for (; j < Xlen; j++)
		c[j][0] = 1;

	for (i = 1; i < Xlen;i++)
	{
		for (j = 1; j < Ylen;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];
		}
	}
}

char *lcs(const char X[], const char Y[], char str[])
{
	int Xlen = strlen(X);
	int Ylen = strlen(Y);
	int c[MAX_LEN][MAX_LEN];

	get_lcslength(X, Xlen, Y, Ylen, c);
	
	int i = Xlen - 1;
	int j = Ylen - 1;

	str[c[i][j]] = '\0';//此時的c[i][j]記錄著最長公共子序列的長度，讓str以'\0'結尾

	while (i > 0 && j > 0)
	{
		if (c[i][j] == c[i][j - 1])
			j = j - 1;
		else if (c[i][j] == c[i - 1][j])
			i = i - 1;
		else
		{
			str[c[i][j] - 1] = X[i];
			i = i - 1;
			j = j - 1;
		}
	}
	/*判斷第0行或者第0列的值，如果為1則表明X[i] == Y[j]*/
	if (c[i][j] == 1)
	{
		if (i == 0)
		{
			str[0] = X[0];
		}
		if (j == 0)
		{
			str[0] = Y[0];
		}
	}
		
	return str;
}

程式的執行結果如下所示：



相關推薦

動態規劃解決最長公共子序列問題

一、相關概念 1 子序列：如果序列Z={z1,z2,z3…zk},可以由序列X={x1,x2,x3…xn}刪除（或不刪除）一些元素得到，則Z為X的一個子序列。Z維持了X序列的相對順序。 2 動態規劃：使用分治法將問題劃分成一個個子問題，當分解的問題共享子問題時，

使用動態規劃解決最長公共子序列問題

一、定義： 給定兩個序列X和Y，如果Z既是X的子序列也是Y的子序列，那麼我們稱Z是X和Y的公共子序列。例如：X={a,b,c,e,d,g,f}，Y={b,e,f,g},那麼Z={b}、Z={b,e}、Z={b,e,f}都是X和Y的公共子序列，其中Z={b，e，f}是X和Y的

【動態規劃】最長公共子序列問題

clas == 搜索 ios for 參考 pan 公式 是否 題目描述： 給定兩個字符串s1s2……sn和t1t2……tn。求出這兩個字符串最長的公共子序列的長度。字符串s1s2……sn的子序列指可以表示為si1si2……sim（i1<i2<……<im）

動態規劃之最長公共子序列（LCS）

int tdi -s can 數組下標 include har 遞推 最長公共子序列 在字符串S中按照其先後順序依次取出若幹個字符，並講它們排列成一個新的字符串，這個字符串就被稱為原字符串的子串 有兩個字符串S1和S2，求一個最長公共子串

動態規劃之最長公共子序列

圖片 輔助 length ret %s csp TP 子序列 輸出 原理請參考《算法導論》 定義常量 enum {upper_left, up, left}; #define LENGTHA (sizeof(A)/sizeof(A[0])) #define LENGTHB

動態規劃之----最長公共子序列

什麽是 資料 lcs 由於 main detail span www. 遞歸 一，問題描述 給定兩個字符串，求解這兩個字符串的最長公共子序列（Longest Common Sequence）。比如字符串1：BDCABA；字符串2：ABCBDAB 則這兩個字符串的最長

【NOJ1041】【DP_動態規劃】最長公共子序列

1041.最長公共子序列 時限：1000ms 記憶體限制：200000K  總時限：3000ms 描述 一個給定序列的子序列是在該序列中刪去若干元素後得到的序列。確切地說，若給定序列X=<x1, x2,…, xm>，則另一序列Z=<z1, z2,

動態規劃實現最長公共子序列

1 public class Test2 { 2 3 static int[][] result; 4 static String str1 = "ABCBDAB"; 5 static String str2 = "BDCABA"; 6 static cha

用動態規劃實現最長公共子序列C語言

思路： 有兩個字元陣列a，b 分為三種情況： 比較a，b陣列當前長度的最後一個字元 相等時， lsc值等於前一段值加1 即：當a[i-1]==b[j-1]時(因為i,j是從1開始，所以是a[i-1],b[j-1])，lsc[i][j]=lsc[i-1][j-1

動態規劃求解最長公共子序列的C++演算法實現

#include<iostream> using namespace std; int CommonOrder(char x[] ,int m ,char y[], int n, char z[]) {     int i,j,k;     int L[10][1

動態規劃之最長公共子序列（C++原始碼）

動態規劃之最長公共子序列 問題： 在序列X={x1,x2,…,xm}與Y={y1,y2,…,yn}中查詢長度最長的公共子序列，往往不是一個。例如：X={A,B,C,B,D,A,B},Y={B,D,C,A,B,A},則公共子序列有Z={B,C,B,A},Z1={B

動態規劃---求最長公共子序列

直接看題： 對於兩個字串，請設計一個高效演算法，求他們的最長公共子序列的長度，這裡的最長公共子序列定義為有兩個序列U1,U2,U3…Un和V1,V2,V3…Vn,其中Ui&ltUi+1，Vi&ltVi+1。且A[Ui] == B[Vi]。 給

hdu1513Palindrome（動態規劃之最長公共子序列變形+滾動陣列）

2題意： 就是填多少字元使之變成迴文字串；#include<iostream> #include<cstring> #include<queue> #include<cstdio> #include<string.h> #include<al

【動態規劃】最長公共子序列與最長公共子串

1. 問題描述 子串應該比較好理解，至於什麼是子序列，這裡給出一個例子：有兩個母串 cnblogs belong 比如序列bo, bg, lg在母串cnblogs與belong中都出現過並且出現順序與母串保持一致，我們將其稱為公共子序列。最長公共子序列（Longest Common Subsequence

MIT演算法導論公開課之第15課 動態規劃、最長公共子序列

動態規劃（Dynamic programming） 動態規劃是一種設計技巧，而不是一種特定的演算法，就像分治法一樣。 最長公共子序列（Longest common subsequence）問題 有兩個序列，序列x[1~m]，序列y[1~n]，找到它們的最長

動態規劃求解最長公共子序列（LCS）

      看了《演算法導論》中文第二版P208的動態規劃求解LCS問題，覺得很贊，但總覺得算導寫得有些晦澀，希望自己能寫得簡單易懂一些，純當鍛鍊了，歡迎指導交流。       首先，子序列和子串是不一樣的。子串是連續的，而子序列中的元素組成可以是不連續的，但元素的位置下標

演算法課堂實驗報告（四）——python動態規劃（最長公共子序列LCS問題）

python實現動態規劃 一、開發環境 開發工具：jupyter notebook 並使用vscode，cmd命令列工具協助程式設計測試演算法,並使用codeblocks輔助編寫C++程式 程式語言：python3.6 二、實驗內容 1.最長公共子序列問題。分別求x=

演算法導論——動態規劃之最長公共子序列（LCS）和最長迴文子序列（LPS）

有兩個字串A和B，假設為A=”abcbdab”,B=”bdcaba”;最長公共子序列（LCS）問題指的時找到A和B的一個公共的子串C，C的長度要是最長。 在這裡我們很明顯的發現最長子序列為”bcba” 用動態規劃的思想來考慮這個問題： 若A={a1,a2,

動態規劃經典——最長公共子序列

最長公共子序列 時間限制：3000 ms | 記憶體限制：65535 KB 難度：3 描述 咱們就不拐彎抹角了，如題，需要你做的就是寫一個程式，得出最長公共子序列。

迴文字串 (動態規劃，最長公共子序列)

迴文字串 時間限制：3000 ms | 記憶體限制：65535 KB 難度：4 描述 所謂迴文字串，就是一個字串，從左到右讀和從右到左讀是完全一樣的，比如"aba"。當然，我們給你的問題不會再簡