【算法】LCS算法以及其JAVA的实现_实现非递归算法求lcs java

LCS问题是动态规划的经典问题，同时也算作入门问题吧。其目的是要求出两个串的最长公共子串。例如如下两个串：

串1：ABCBDAB

串2：BDCABA

那么，它们的最长公共子序列是BCBA。注意，最长公共子序列不是最长的公共串，最长的公共串在leetcode里面好像有过这么一道题，用暴力求解的方法也能在很短的时间内算出来，不会耗费太长的时间。但是最长的公共子序列不是连续的，要找出来，就需要将串中所有的可能都列举出来，这就需要指数级别的时间复杂度了。用纯暴力的算法就能难在很短的时间内计算出来。所以就有了我们动态规划的LCS算法。

看看书上的关于LCS最优子结构的定理：

令X = <x1,...xm>  Y=<y1,....yn>为两个序列，Z为X,Y中的任意LCS：

1.如果Xm = Yn , 那么Zk != Xm,且Zk-1 为 Xm-1 的一个LCS 

2.如果Xm != Yn , 那么Zk ! = Yn ,且Zk-1 为 Yn-1的一个LCS 

那么，我们如何在代码中构造标识LCS呢？

首先我们定义两个二维矩阵，B和C，维度为两个串的长度+1。然后按照如下的规则循环或地柜生成对应的矩阵。

1.如果i=0或者j=0: c[i][j]=0,   b[i][j]=' '.

2.如果i,j>0且x[i]=y[j]   c[i][j] = c[i-1][j-1] +1, b[i][j] = 'x'代表上箭头

3.如果i,j>0且x[i]!=y[j]  c[i][j] = max(c[i-1][j] ,c[i-1][j-1])    b[i][j] = 'h' or 'w'代表竖向箭头和横向箭头

生成的矩阵如下图所示：其中x指代斜向箭头，h指代竖向箭头，w指向横向箭头：

然后，按照递归的方式，从最后一栏依次往前找，如果是斜箭头，就记录此时的双向值，竖向箭头就往上一移动，横向箭头就往左移动。最后得出按如下结果：

每次转折点就是要得到的公共子串。

下面是java实现的代码：

 

private Stack<Character> stack = new Stack<Character>();
	private void printLcs(char d[][], String a, int i ,int j)
	{
		if(i==0||j==0)
		{}
		else if(d[i][j]=='x')
		{
			stack.push(a.charAt(i-1));
			printLcs(d,a,i-1,j-1);
		}
		else if (d[i][j]=='h')
			printLcs(d,a,i-1,j);
		else
			printLcs(d,a,i,j-1);
	}
	public String getLCS(String a,String b)
	{
		int[][] c = new int[a.length()+1][b.length()+1];
		char[][] d = new char [a.length()+1][b.length()+1];
		for(int i = 0; i<=a.length();i++)
			c[i][0]=0;
		for(int j = 0; j<=b.length();j++)
			d[0][j]=0;
		for(int i = 1; i<=a.length();i++)
		{
			for(int j = 1; j<=b.length();j++)
			{
				if(a.charAt(i-1)==b.charAt(j-1))
				{
					c[i][j] = c[i-1][j-1]+1;	d[i][j] = 'x';
				}
				else if (c[i-1][j] >= c[i][j-1])
				{
					c[i][j] = c[i-1][j];		d[i][j] = 'h';
				}
				else
				{
					c[i][j] = c[i][j-1];		d[i][j] = 'w';
				}
			}
		}
 
		printLcs(d , a , a.length(),b.length());
		String res = "";
		while(!stack.empty())
			res += stack.pop().toString();
		return res;
	}