動態規划(實現最長公共子序列以及最長公共子字符串)


動態規划法

       經常會遇到復雜問題不能簡單地分解成幾個子問題,而會分解出一系列的子問題。簡單地采用把大問題分解成子問題,並綜合子問題的解導出大問題的解的方法,問題求解耗時會按問題規模呈冪級數增加。
       為了節約重復求相同子問題的時間,引入一個數組,不管它們是否對最終解有用,把所有子問題的解存於該數組中,這就是動態規划法所采用的基本方法。

【問題】 求兩字符序列的最長公共字符子序列

       字符序列的子序列是指從給定字符序列中隨意地(不一定連續)去掉若干個字符(可能一個也不去掉)后所形成的字符序列。令給定的字符序列X=“x0,x1,…,xm-1”,序列Y=“y0,y1,…,yk-1”是X的子序列,存在X的一個嚴格遞增下標序列 <i0,i1,…,ik-1>,使得對所有的j=0,1,…,k-1,有xij=yj。例如,X=“ABCBDAB”,Y=“BCDB”是X的一個子序列。

       考慮最長公共子序列問題如何分解成子問題,設A=“a0,a1,…,am-1”,B=“b0,b1,…,bn-1”,並Z=“z0,z1,…,zk-1”為它們的最長公共子序列。不難證明有以下性質:
(1) 如果am-1=bn-1,則zk-1=am-1=bn-1,且“z0,z1,…,zk-2”是“a0,a1,…,am- 2”和“b0,b1,…,bn-2”的一個最長公共子序列;
(2) 如果am-1!=bn-1,則若zk-1!=am-1,蘊涵“z0,z1,…,zk-1”是“a0,a1,…,am-2”和“b0,b1,…,bn-1”的一個最長公共子序列;
(3) 如果am-1!=bn-1,則若zk-1!=bn-1,蘊涵“z0,z1,…,zk-1”是“a0,a1,…,am-1”和“b0,b1,…,bn-2”的一個最長公共子序列。

       這樣,在找A和B的公共子序列時,如有am-1=bn-1,則進一步解決一個子問題,找“a0,a1,…,am-2”和“b0,b1,…,bm-2”的一個最長公共子序列;如果am-1!=bn-1,則要解決兩個子問題,找出“a0,a1,…,am-2”和“b0,b1,…,bn-1”的一個最長公共子序列和找出“a0,a1,…,am-1”和“b0,b1,…,bn-2”的一個最長公共子序列,再取兩者中較長者作為A和B的最長公共子序列。

  • 求解:

       引進一個二維數組c[][],用c[i][j]記錄X[i]與Y[j] 的LCS 的長度,b[i][j]記錄c[i][j]是通過哪一個子問題的值求得的,以決定搜索的方向。
       我們是自底向上進行遞推計算,那么在計算c[i,j]之前,c[i-1][j-1],c[i-1][j]與c[i][j-1]均已計算出來。此時我們根據X[i] = Y[j]還是X[i] != Y[j],就可以計算出c[i][j]。

  • 問題的遞歸式寫成:
    這里寫圖片描述

  • 回溯輸出最長公共子序列過程:

這里寫圖片描述

  • 算法分析:

       由於每次調用至少向上或向左(或向上向左同時)移動一步,故最多調用(m * n)次就會遇到i = 0或j = 0的情況,此時開始返回。返回時與遞歸調用時方向相反,步數相同,故算法時間復雜度為Θ(m * n)。

  • 代碼實現:
public class LCSProblem 
{

public static void main(String[] args)
{
//保留空字符串是為了getLength()方法的完整性也可以不保留
//但是在getLength()方法里面必須額外的初始化c[][]第一個行第一列
String[] x = {"", "A", "B", "C", "B", "D", "A", "B"}; //之所以要空出第一行(列),是因為c[][]里面意思是兩個字符數組分別多少個,0的意思就是某個串長度為0
String[] y = {"", "B", "D", "C", "A", "B", "A"};

int[][] b = getLength(x, y);

Display(b, x, x.length-1, y.length-1);
}
/**
* @param x
* @param y
* @return 返回一個記錄決定搜索的方向的數組
*/

public static int[][] getLength(String[] x, String[] y)
{
int[][] b = new int[x.length][y.length];
int[][] c = new int[x.length][y.length];

for(int i=1; i<x.length; i++)
{
for(int j=1; j<y.length; j++)
{
//對應第一個性質
if( x[i] == y[j])
{
c[i][j] = c[i-1][j-1] + 1;
b[i][j] = 1;
}
//對應第二或者第三個性質
else if(c[i-1][j] >= c[i][j-1])
{
c[i][j] = c[i-1][j];
b[i][j] = 0;
}
//對應第二或者第三個性質
else
{
c[i][j] = c[i][j-1];
b[i][j] = -1;
}
}
}

return b;
}
//回溯的基本實現,采取遞歸的方式
public static void Display(int[][] b, String[] x, int i, int j)
{
if(i == 0 || j == 0)
return;

if(b[i][j] == 1)
{
Display(b, x, i-1, j-1);
System.out.print(x[i] + " ");
}
else if(b[i][j] == 0)
{
Display(b, x, i-1, j);
}
else if(b[i][j] == -1)
{
Display(b, x, i, j-1);
}
}
}

問題:最長公共子字符串

       類似最長子序列,只是公共子字符串要求必須是連續的。子字符串的定義和子序列的定義類似,但要求是連續分布在其他字符串中。比如輸入兩個字符串BDCABA和ABCBDAB的最長公共字符串有BD和AB,它們的長度都是2。

  • 最長公共子字符串共有兩種解決方法:

方法一:

       Longest Common Substring和Longest Common Subsequence是有區別的
       X = <a, b, c, f, b, c>
       Y = <a, b, f, c, a, b>
        X和Y的Longest Common Sequence為<a, b, c, b>,長度為4
       X和Y的Longest Common Substring為 <a, b>長度為2

        其實Substring問題是Subsequence問題的特殊情況,也是要找兩個遞增的下標序列
<i1, i2, …ik> 和 <j1, j2, …, jk>使
        xi1 == yj1
        xi2 == yj2
        ……
        xik == yjk

       與Subsequence問題不同的是,Substring問題不光要求下標序列是遞增的,還要求每次
遞增的增量為1, 即兩個下標序列為:
<i, i+1, i+2, …, i+k-1> 和 <j, j+1, j+2, …, j+k-1>

       類比Subquence問題的動態規划解法,Substring也可以用動態規划解決,令
c[i][j]表示Xi和Yi的最大Substring的長度,比如(到i,j為止,最長的,包括i,j處的字符)

        X = <y, e, d, f>
        Y = <y, e, k, f>
        c[1][1] = 1
        c[2][2] = 2
        c[3][3] = 0

動態轉移方程為:
        如果xi == yj, 則 c[i][j] = c[i-1][j-1]+1
        如果xi ! = yj, 那么c[i][j] = 0
        最后求Longest Common Substring的長度等於 max{ c[i][j], 1<=i<=n, 1<=j<=m}

代碼如下:
注意:第一行第一列應該為空:

public static void LCP_String(char[] str1,char[] str2){  
int[][] c = new int[str1.length][str2.length];
Stack<Character> stack = new Stack<Character>();
int max = 0; // store the max length of the LCP String
int x = 0;
int y = 0;

for(int i=1;i<str1.length;i++){
for(int j=1;j<str2.length;j++){
if(str1[i] == str2[j]){
c[i][j] = c[i-1][j-1]+1;
}else{
c[i][j] = 0;
}
if(c[i][j] > max){
max = c[i][j];
x = i;
y = j;
}
}
}
System.out.println(max);
for(int i=x, j=y;c[i][j] != 0;i--,j--){
stack.add(str1[i]);
}
while(!stack.isEmpty()){
System.out.print(stack.pop());
}
}

注意!

本站转载的文章为个人学习借鉴使用,本站对版权不负任何法律责任。如果侵犯了您的隐私权益,请联系我们删除。



 
粤ICP备14056181号  © 2014-2021 ITdaan.com