2个巨大文件之间的最长公共子字符串 - 内存不足：java堆空间答案

【问题标题】：longest common substring between 2 HUGE files - out of memory: java heap space2个巨大文件之间的最长公共子字符串 - 内存不足：java堆空间
【发布时间】：2014-05-19 20:08:19
【问题描述】：

在这之后我完全脑筋急转弯，我需要找到两个文件之间最长的公共子字符串，一个小文件和一个大文件。我什至不知道从哪里开始搜索，这就是我目前所拥有的

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class MyString
{
    public static void main (String[] args) throws IOException
    {
        BufferedReader br = new BufferedReader(new FileReader("MobyDick.txt"));
        BufferedReader br2 = new BufferedReader(new FileReader("WarAndPeace.txt"));
        String md, wp;
        StringBuilder s = new StringBuilder();
        while ((md = br.readLine()) != null)
        {
            s.append(md).append(" ");
        }
        md = s + "";
        s.setLength(0);
        while ((wp = br2.readLine()) != null)
        {
            s.append(wp).append(" ");
        }
        wp = s + "";
        s.setLength(0);

        md = md.replaceAll("\\s+", " "); //rids of double spaces
        wp = wp.replaceAll("\\s+", " "); //rids of double spaces
    }
}

到目前为止，我所做的是将每个文件放入一个字符串构建器中，然后放入一个字符串中以消除双空格（在 MobyDick.txt 上出现了很多）。我找到了这段代码

public static String longestSubstring(String str1, String str2) {

StringBuilder sb = new StringBuilder();
if (str1 == null || str1.isEmpty() || str2 == null || str2.isEmpty())
  return "";

// ignore case
str1 = str1.toLowerCase();
str2 = str2.toLowerCase();

// java initializes them already with 0
int[][] num = new int[str1.length()][str2.length()];
int maxlen = 0;
int lastSubsBegin = 0;

for (int i = 0; i < str1.length(); i++) {
for (int j = 0; j < str2.length(); j++) {
if (str1.charAt(i) == str2.charAt(j)) {
if ((i == 0) || (j == 0))
   num[i][j] = 1;
else
   num[i][j] = 1 + num[i - 1][j - 1];

if (num[i][j] > maxlen) {
  maxlen = num[i][j];
  // generate substring from str1 => i
  int thisSubsBegin = i - num[i][j] + 1;
  if (lastSubsBegin == thisSubsBegin) {
     //if the current LCS is the same as the last time this block ran
     sb.append(str1.charAt(i));
  } else {
     //this block resets the string builder if a different LCS is found
     lastSubsBegin = thisSubsBegin;
     sb = new StringBuilder();
     sb.append(str1.substring(lastSubsBegin, i + 1));
  }
  }
  }
  }}

  return sb.toString();
  }

这段代码有帮助，但只对小文件有帮助，每次我用大文件运行它时，我都会得到一个 “内存不足：java 堆空间”错误。我需要正确的算法来摆脱堆空间问题，而且我无法增加 java 内存，谁能帮助或指出正确的方向？

【问题讨论】：

也许你应该看看你解决问题的方式。为了节省内存，我想到的一件事是您应该只处理最小文件大小的块（因为这是最大的潜在匹配）。在比较小文件和大文件的第一个块之后，迭代它。不是最有效的方法，但也许它会让你朝着正确的方向开始。
我确实尝试过这样做，在这一行 int[][] num = new int[str1.length()][str2.length()];它可以是 1000 的最大数量（反复试验）所以我想我可以将文本分成每 100 万个字符的 1000 个部分，但 WarAndPeace 大约有 300 万个字符，这需要 4000 多个部分的文本，这一样糟糕，因为我还需要担心需要多长时间。
您可能需要查看this thread，因为它也在比较大文件。我建议在担心速度之前先考虑让它运行（并不总是最好的规则，但得到一些东西通常可以让我们了解如何做一个更快的方法）。不过，我相信，您最好将两个文本分成较小的部分，然后比较这些较小的部分。关键是要确保您考虑到超出块大小的匹配项。

标签： java lcs longest-substring

【解决方案1】：

首先你需要准确地确定为什么这是一个如此大的内存消耗，然后你可以开始解决它。

这个声明作为一个潜在的问题跳出来：

int[][] num = new int[str1.length()][str2.length()];

《战争与和平》的长度超过 300 万个字符，而《白鲸记》的长度大约是它的一半，所以我们保守地说它有 100 万个字符。

您正在尝试为 3,000,000,000,000 个整数分配空间，每个整数为 4 字节，计算结果为 12,000,000,000,000 字节或略低于 11 TB。

希望很清楚为什么该算法不适合这种长度的字符串。

值得庆幸的是，计算机科学的主要理论之一是你总是可以用时间来换取内存，反之亦然。

相反，您想尝试generalized suffix tree。这具有 \Theta(n + m) 的内存成本，并且可以在更易于管理的 \Theta(n + m) 中构建。

Here 是生成此类树的 O(n) 算法的极好指南。

一旦你有了后缀树，就可以在恒定时间内找到 LCS，方法是找到树中最深的节点，其子树包含两个输入字符串的子字符串。一个典型的策略是，如果满足属性，则用标志“i”标记所有节点“v”：

根为 v 的子树包含字符串 S_i 的子字符串

然后找到最深的节点v，其中v被标记为i，对于范围内的所有i（在这种情况下，只有0和1）。

【讨论】：