动态编程：位数组 Java

Question

我需要解决一个Dynamic Programming 问题，为此我需要在内存中创建一个N*N 大小矩阵。如果我确实创建了一个byte[][] 的矩阵，大小为N = 100000;，那么它会抛出java.lang.OutOfMemoryError: Java heap space 错误。

在这个矩阵中，我将在特定的 ith 和 jth 索引处存储 0 或 1。所以我的使用仅限于一点，我需要一种方法，以便我可以只使用每个矩阵单元的 1 位大小，而不是过度淹没内存，将 8 位保留在一个只需要 1 位的单元中。

我怎样才能做到这一点？

请注意，我关心的不是增加 JVM 堆，我只是在寻找一种方法来优化解决动态问题。

Answer 1

更新：我刚刚检查过，不幸的是，忘记了BitSet。

BitSet 的巧妙 API 建立在 int 索引之上。整数范围超出了N * N 的范围。因此，您需要自己实现一些东西。一个建议：

public class BetterBitSet {

  private final long[] values;

  public BetterBitSet(int dimension) {
    values = new long[(int) ((long) dimension) * dimension / 8 / 64 + 1];
  }

  public void set(int i, int j, boolean value) {
    long index = index(i, j);
    int arrayIndex = arrayIndex(index);
    if (value) {
        values[arrayIndex] = set(values[arrayIndex], offset(index));
    } else {
        values[arrayIndex] = unset(values[arrayIndex], offset(index));
    }
  }

  public boolean isSet(int i, int j) {
    long index = index(i, j);
    return isSet(values[arrayIndex(index)], offset(index));
  }

  private boolean isSet(long value, int bitIndex) {
    return (value & (1L << bitIndex)) != 0;
  }

  private long set(long value, int bitIndex) {
    return value | (1L << bitIndex);
  }

  private long unset(long value, int bitIndex) {
    return value & ~(1L << bitIndex);
  }

  private long index(int i, int j) {
    return j * 8L + i;
  }

  private int arrayIndex(long index) {
    return (int) index / 64;
  }

  private int offset(long index) {
    return (int) index % 64;
  }
}

如有疑问，请查看BitSet 的源代码并尝试类似的方法。

旧答案：问题是byte[][] 的每个索引都需要8 位，而您只存储大约1 位的信息。这需要 9,536 MB 来在堆上分配这个数组，所以空间不足。这个内存量很可能对您的机器来说太多了。但是，使用存储位，您仍然需要 1,192 MB。 （不考虑由BitSet 引起的任何开销。）这仍然是一个很大的数字，因此请确保您的机器提供了足够多的空间，您必须另外分配给您的 JVM 实例。

Answer 2

Java 提供了一种托管的基于位的数据结构，称为BitSet。我说这是托管的，因为 Java 没有用于存储位的本机类型，相反，BitSet 将各个位存储为long 的一个组件，并保留一个long[] 来支持该集合。这是一种非常节省存储的方法，但是implementation of BitSet 在每 64 位中保留 6 位用于“寻址”，这相当于原始存储层中 10% 的开销。

这意味着您可以通过保留并仔细处理自己的long[] 在存储方面击败BitSet，但代价是代码中的一些复杂性和风险。除非您在空间上受到极大限制，否则可能不值得节省 BitSet 的约 10% 的原始开销。

上面描述的两种解决方案都是一维位数组，这可能也毫无价值。您可以通过将一维数组视为行的串联来轻松地将二维数组转换为一维数组（至少，在这种情况下，您似乎假设行宽相等）。处理矩阵中的特定单元格很简单：

row * (row_width) + column

Answer 3

在许多情况下，您不需要所有子问题来评估当前问题，因此我建议使用 hashmap 的递归自上而下解决 DP 问题来存储解决方案。使用子问题后，您可以将其从 hashmap 中删除以防止溢出。 有时会有轻微的性能损失，但会防止内存已满错误。

Memoization