经典算法学习_动态规划_最长公共子序列

前几天做笔试题，遇到最长递增子序列的问题，不知怎么解，看网上有一种先将该序列排序，以转化为求新序列与原有序列的最长公共子串。然而，最长公共子序列也！不！会！

这两个算法在大学时都应该是接触过的，到此时居然已经忘的一干二净，才知道自己究竟差了多少功夫。于是先学一下最长公共子序列的解法，在这里记下来，待下次再不会做时也好有个查阅的好地方。最长递增子序列的解法改天再学。

设有字符串a，b。

记a(0,i)为a从0位到i位的子串。

使用二维数组c来记录最长公共子序列长度，c[i][j]表示a(0,i)与b(0,j)的最长公共子序列长度。设c[-1][j] = c[i][-1] = 0，不论 i，j 取何值。

动态规划的思路如下：

1）若a[i] == b[j]，则c[i][j] = c[i-1][j-1] + 1

2）若a[i] != b[j]，则c[i][j] = max{c[i-1][j], c[i][j-1]}

在其后构造最长公共子序列时，则逆向使用求最长公共子序列长度时的数据。首先初始化空的字符串。

从表c右下角开始循环，记c[i][j]，每次在下列三个表项中查找最大值

a) c[i-1][j]

b) c[i][j-1]

c) c[i-1][j-1]

若a)最大，则令 i = i - 1

若b)最大，则令 j = j - 1

若c)最大，则在字符串前插入a[i]的字符，而后令 i = i - 1，j = j - 1

其中可能出现 a)，b) 两数值相等，则说明有两种构造最长公共子序列的方式，这两种子序列可能相同，也可能不同。

为了简化这个过程，也可以构造二维数组d，来存储构造最长公共子序列时，i，j 的调整方向。

二维数组c的示意图如下，来自算法导论第三版。



写练习代码如下，未仔细推敲，大致应该或许没有错…

public class LCS
{
public static void main(String[] args)
{
String strA = "ABCBDABDEWKJFIEWJFDJKSLVJIWE";
String strB = "BDCABAFJEWKOCDJNIFJWEKFLWE";
LCS aLCS = new LCS();
aLCS.calLength(strA, strB);
System.out.println("The LCS = \""+aLCS.getLCS(strA, strB)+"\"");
}

public int calLength(String a, String b)
{
//获得初始化表的长度,将字符串的长度加1，
//作为表的第一行和第一列全部为0的数据，
//以统一运算，避免在循环中加入条件判断语句。
int lenA = a.length() + 1;
int lenB = b.length() + 1;
//第i行第j列的数值表示a(0,i-1)和b(0，j-1)的最大匹配长度
lengthTab = new int[lenA][lenB];
//第i行第j列的数值表示a(0,i-1)和b(0，j-1)的最大匹配长度根据哪个单元获得，具体数值见实例域定义
directTab = new int[lenA][lenB];

//按行开始遍历
for(int i=1; i<lenA; i++)
{
//对第i行的每一个单元
for(int j=1; j<lenB; j++)
{
//若a字符串的第i-1个字符和b字符串的第j-1个字符相同
//则说明a(0,i-1)和b(0,j-1)的最大匹配长度是a(0,i-2)和b(0,j-2)匹配长度加1
if(a.charAt(i-1) == b.charAt(j-1))
{
directTab[i][j] = this.TOP_AND_LEFT;
lengthTab[i][j] = lengthTab[i-1][j-1] + 1;
}
else
{
//若a字符串的第i-1个字符和b字符串的第j-1个字符不同
//则说明a(0,i-1)和b(0,j-1)的最大匹配长度是a(0,i-2)和b(0,j-2)最大匹配长度相同
if(lengthTab[i-1][j] > lengthTab[i][j-1])
{
directTab[i][j] = this.TOP;
lengthTab[i][j] = lengthTab[i-1][j];
}
else if(lengthTab[i-1][j] < lengthTab[i][j-1])
{
directTab[i][j] = this.LEFT;
lengthTab[i][j] = lengthTab[i][j-1];
}
else
{
directTab[i][j] = this.TOP_OR_LEFT;
lengthTab[i][j] = lengthTab[i-1][j];
}
}
}
}
//      System.out.println("LengthTab:");
//      printTab(lengthTab);
//      System.out.println("DirectTab:");
//      printTab(directTab);
return lengthTab[lenA-1][lenB-1];
}

public String getLCS(String a, String b)
{
StringBuilder sb = new StringBuilder();
if(directTab==null)
{
return "";
}
//检验directTab行数和列数是否与字符串长度匹配
if(directTab.length != a.length() + 1)
return "";
if(directTab.length <= 0 || directTab[0].length != b.length() + 1)
return "";

int lenA = directTab.length - 1;
int lenB = directTab[0].length - 1;

//在表中查找使匹配长度最大的路线（其中一条）
while(lenA > 0 && lenB > 0)
{
//若该单元记录为TOP_AND_LEFT，说明在此最大匹配子串的构造中，包含a.charAt(lenA-1)
if(directTab[lenA][lenB] == this.TOP_AND_LEFT)
{
sb.insert(0, a.charAt(lenA-1));
lenA--;
lenB--;
}
//若此最大匹配子串的构造中，不包含a.charAt(lenA-1)，寻找下一个包含在子串中的字符
else if(directTab[lenA][lenB] == this.TOP)
{
lenA--;
}
else if(directTab[lenA][lenB] == this.LEFT)
{
lenB--;
}
else
{
//
//存在多个最长公共子序列，假设取左
lenB--;
}
}
return sb.toString();
}

public void printTab(int[][] tab)
{
for(int[] line : tab)
{
for(int element : line)
{
System.out.printf("%4d ", element);
}
System.out.println();
}
}

private int[][] lengthTab = null;
private int[][] directTab = null;

//表示这一个单元的最大匹配长度是从上一行同一列获得
public static final int TOP = -1;
//表示这一个单元的最大匹配长度是从前一列同一行获得
public static final int LEFT = 0;
//表示这一个单元的最大匹配长度是左上角单元数值加1获得
public static final int TOP_AND_LEFT = 1;
//表示这一个单元的最大匹配长度同其左侧及上方的单元都一样，
//TOP_OR_LEFT原为找到所有最长公共子序列而设，在这个例子中没有实际使用，也未经测试是否有效，
//为避免有不同路径的相同匹配子序列，可使用TreeSet等集合返回查找结果，
//但需要注意克隆方法，以及String类的Comparable接口实现情况。
public static final int TOP_OR_LEFT = 2;
}