LCS问题
来源:互联网 发布:软件数据接口开发合同 编辑:程序博客网 时间:2024/05/19 16:49
- LCS问题
- 简介
- 最长公共子串问题
- 最长公共子序列问题
- References
LCS问题
1. 简介
LCS通常是指Longest Common Subsequence, 但是也可代指Longest Common Substring。子串是一种特殊的子序列,子串和子序列的区别就是字串要求是组成子串的
各字符是连续的,而子序列仅仅要求各字符的下标是递增的即可。举个例子,如helloworld
, world
是子串(也是子序列), hw
不是子串是子序列。
LCS问题就是在若干(这里是两个)字符串中,找到最长的一个字符串p, 这个p是那些字符串的子串(子序列)。LCS问题的意义之一就是去衡量若干字符串的相似度,例如在生物信息学
中有DNA序列的问题,比如序列a = "ATGATAGATAGATAG"
, 序列b="TGGGCCGAGAAGCGAGA"
,需要一种去衡量a
、b
相似度的方法,那么最长公共子序列就可以作为一种衡量方法。
除此之外,在软件开发领域中的版本控制系统(典型的就是Git
),比较同一个文件不同时刻的差异的时候,就需要利用到这个方法。
例如下图就是Git
上面的两次不同时刻对同一个文件的快照的对比图,我们可以看到,系统把两次的差异标示出来了。而原来位置、内容相同的部分没有标示。这个就可以通过 LCS
问题的解决,来找到最长的公共子序列部分,就是作为公共的、未发生改变部分;剩下的就是改变的部分,应该标示出来。
同理基于这个,我们还可以简单的比较两篇文章的相似度来检查雷同、抄袭的情况,这么看来,LCS问题的还是和我们日常比较相关的。
解决LCS问题依靠暴力(brute force)的求解时间复杂度是指数级别的,因此不太现实,由于问题的本身的最优解具有最优子结构特征,因此原问题的求解可以化为多个子问题的求解;另外子问题的求解存在重叠的情况,这恰好是适合动态规划求解的问题的第二个特征:存在重叠的子问题求解过程,因此适合利用动态规划来求解,这个也是较常见的解决LCS问题的方法,时间复杂度为O(n*m)
,动态规划易于编写,但是时间复杂度较高;另外更高级的还存在一种线性复杂度的O(n+m)
的解法,就是Suffix Tree
,不过这种方法的缺点是程序难以编制。因此在日常的编码中,动态规划已经够用了。
2. 最长公共子串问题
设dp[i][j]表示s[0~i]和t[0~j]的最长公共子串的长度,对于两个字符串的最长公共子串问题的最优解,最优解存在如下结构:
dp[i][j] = 1 (i == 0 || j == 0)dp[i][j] = dp[i-1][j-1] + 1;(s[i] == t[j] && i > 0 && j > 0);dp[i][j] = 0;(s[i] != t[j])
上述等式建立了原问题和子问题的关系(此类证明可用反证法),剩下的就是编码了。
public static List<String> findLongestLCS(String s, String t) { char[] schs = s.toCharArray(); char[] tchs = t.toCharArray(); int m = s.length(), n = t.length(); int[][] dp = new int[m][n]; int maxSize = 0; List<Integer> indexs = new ArrayList<>();//存储最长公共子串的在原始串中结束位置 for (int i = 0; i < m; i++) for (int j = 0; j < n; j++) { if (schs[i] == tchs[j]) { if (i == 0 || j == 0) dp[i][j] = 1; else dp[i][j] = dp[i - 1][j - 1] + 1; if (dp[i][j] > maxSize) { maxSize = dp[i][j]; indexs.clear();//找到更优的解,前面存储的下标值全部作废 indexs.add(i); } else if (dp[i][j] == maxSize) indexs.add(i); } else dp[i][j] = 0; } List<String> ret = new ArrayList<>(); for (Integer i : indexs) ret.add(s.substring(i + 1 - maxSize, i + 1)); return ret; }
改进:上面的版本时间复杂度是O(n*m)
,空间复杂度也是O(n*m)
;但是观察dp二维数组发现,发现有优化的余地。由于在计算dp[i][j]的时候只使用到了dp[i-1][j-1],因此dp二维数组可以使用一个一位数组和两个临时变量即可完成,这样就把空间复杂度降低到O(min(n, m))
。
改进版本
// 内存改进版本, 只存储one row,新增两个临时变量空间复杂度O(min(m, n)) public static List<String> findLongestLCS0(String s, String t) { String tmp = s; if (s.length() > t.length()) { s = t; t = tmp; } char[] schs = s.toCharArray(); char[] tchs = t.toCharArray(); int m = s.length(), n = t.length(); int[] dp = new int[m]; //prev存储dp[i-1][j-1],cur存储dp[i][j] int prev = 0, cur = 0; int maxSize = 0; List<Integer> indexs = new ArrayList<>(); for (int i = 0; i < n; i++) for (int j = 0; j < m; j++) if (schs[j] == tchs[i]) { if (i == 0 || j == 0) dp[j] = 1; else { cur = dp[j]; dp[j] = prev + 1; prev = cur; } if (dp[j] > maxSize) { maxSize = dp[j]; indexs.clear(); indexs.add(j); } else if (dp[j] == maxSize) indexs.add(j); } else { cur = dp[j]; dp[j] = 0; prev = cur; } List<String> ret = new ArrayList<>(); for (Integer j : indexs) ret.add(s.substring(j + 1 - maxSize, j + 1)); return ret; }
如果上面的dp数组很稀疏(0值很多),当字符串很大时,也还可以继续优化,采用hashmap
的方式存储非0值,这样在字符串大且dp数组稀疏的时候,可以进一步优化。
// 内存改进版1 用hashtable存储每一行dp的非0值 public static List<String> findLongestLCS1(String s, String t) { String tmp = s; if (s.length() > t.length()) { s = t; t = tmp; } char[] schs = s.toCharArray(); char[] tchs = t.toCharArray(); int m = s.length(), n = t.length(); Map<Integer, Integer> dp = new HashMap<>(); int prev = 0, cur = 0; int maxSize = 0; List<Integer> indexs = new ArrayList<>(); for (int i = 0; i < n; i++) for (int j = 0; j < m; j++) { Integer tmpj = dp.get(j); if (schs[j] == tchs[i]) { if (i == 0 || j == 0) dp.put(j, 1); else { cur = tmpj == null ? 0 : tmpj; dp.put(j, prev + 1); prev = cur; } tmpj = dp.get(j); if (tmpj > maxSize) { maxSize = tmpj; indexs.clear(); indexs.add(j); } else if (tmpj == maxSize) indexs.add(j); } else { //非0值不存储, 优化稀疏情况。 cur = tmpj == null ? 0 : tmpj; dp.remove(j); prev = cur; } } System.out.println(indexs); List<String> ret = new ArrayList<>(); for (Integer j : indexs) ret.add(s.substring(j + 1 - maxSize, j + 1)); return ret; }
3. 最长公共子序列问题
同样的最长公共子序列也可以利用刻画最优解的结构来利用DP求解。
对于字符串s和t,和上面一样dp[i][j]存储的值依然是s[0~i]和t[0~j]的最长公共子序列的长度。
最优解的结构
dp[i][j] = 1 (i == 0 || j == 0 && s[i] == t[j])dp[i][j] = 0 (i == 0 || j == 0 && s[i] != t[j])dp[i][j] = dp[i-1][j-1] + 1(i > 0 && j > 0 && s[i] == t[j])dp[i][j] = max(dp[i-1][j], dp[i][j-1])(i > 0 && j > 0 && s[i] != t[j])
具体证明参见《算法讨导论》,也是利用反证法。
由于计算的时候只使用到了dp[i-1][j-1]、dp[i-1][j]和dp[i][j-1],则可以运用上上文中的思路,进行空间优化。
//只需要求解长度,可以进行空间优化 public static int longestLCS(String s, String t) { String tmp = s; if (s.length() > t.length()) { s = t; t = tmp; } char[] schs = s.toCharArray(); char[] tchs = t.toCharArray(); int m = s.length(), n = t.length(), prev = 0, cur; int[] dp = new int[m]; for (int j = 0; j < n; j++) for (int i = 0; i < m; i++) { if (schs[i] == tchs[j]) { if (i == 0 || j == 0) dp[i] = 1; else { cur = dp[i]; dp[i] = prev + 1;//prev ---> dp[i-1][j-1] prev = cur; } } else { cur = dp[i]; int aa = i == 0 ? 0 : dp[i-1], bb = j == 0 ? 0 : dp[i]; dp[i] = Math.max(aa, bb); prev = cur; } } return dp[m-1]; }
但是由于有些时候,我们需要知道这些最长公共子序列,因此我们还需要在求解的过程保存额外的信息(上文中保存的是下标值)。为了得到最长公共子序列,我们可以
沿着求解反方向去得到最长公共子序列。具体的做法就是,给定一个dp[i][j]我们可以判断出,它是由dp[i][j-1]还是dp[i-1][j]还是dp[i-1][j-1]得来的,知道了这个以后我们就知道了求解方向了,这样可以逆着回退到起点dp[0][0]。
public static String longestLCSWithReconstructionLCS(String a, String b) { char[] achs = a.toCharArray(); char[] bchs = b.toCharArray(); int m = a.length(), n = b.length(); int[][] dp = new int[m][n]; StringBuilder sb = new StringBuilder(); for (int i = 0; i < m; i++) for (int j = 0; j < n; j++) { if (achs[i] == bchs[j]) { if (i == 0 || j == 0) dp[i][j] = 1; else dp[i][j] = dp[i - 1][j - 1] + 1; } else { int aa = i == 0 ? 0 : dp[i - 1][j], bb = j == 0 ? 0 : dp[i][j - 1]; dp[i][j] = Math.max(aa, bb); } } // 重构最长公共子序列 int i = m - 1, j = n - 1; while (i >= 0 && j >= 0) { //判断方向 if (achs[i] == bchs[j]) {//如果相等,必然是子序列的一部分 sb.append(achs[i]); i--;j--; } else {//如果不相等,则需要判断求解方向,然后逆行。 if (dp[i - 1][j] >= dp[i][j - 1]) i--; else j--; } } return sb.reverse().toString(); }
我们可以在O(n)
的时间重构得到最长公共子序列,由于我们需要在最后逆行构造最长公共子序列,因此是不能将二维数组dp优化成一位数组dp,因为优化以后我们是没法
在O(1)
的时间判断出由dp[i][j-1]还是dp[i-1][j]还是dp[i-1][j-1]得来的,重构最长公共子序列也就无从谈起了。
4. References
[1] Longest_common_subsequence_problem
[2] Suffix Tree
[3] Thomas H.Cormen, Charles E.Leiserson, Ronald L.Rivest, Clifford Stein.算法导论[M].北京:机械工业出版社,2015:222-226
- LCS问题
- lcs问题
- LCS 问题
- LCS问题
- LCS 问题
- LCS问题
- 【codevs 1862】LCS问题+LCS的计数
- LCS问题算法
- TYVJ1029:LCS问题
- LCS问题,JAVA实现
- LCS 问题的解决办法
- LCS简单问题
- SDUTOJ. LCS问题.(DP)
- LCS相关问题
- LCS问题不全汇总
- 【DP,lcs问题】整理队形
- LCS问题的另一种解法
- POJ 2250 Compromise(LCS问题)
- 打印三角形(循环结构)
- Ubuntu上安装JDK并配置环境
- POJ
- 绕过前端加密进行爆破(附脚本)
- 数据结构实验之图论二:图的深度遍历
- LCS问题
- Codeforces Round #447 (Div. 2) C. Marco and GCD Sequence
- 【开源社区】如何参与JEECG开源团队?
- const 和一级指针、二级指针、引用的结合使用总结
- Kotlin+Retrofit+Rxjava开发(未完待续)
- week11-leetcode #451-Sort-Characters-By-Frequency
- PYcharm的快捷键总结
- 第三代ARM存储系统到来
- 如何使用 objdump 查看源代码