java - 动态规划斐波那契数列

Question

我正在学习动态规划在斐波那契数列中的应用并有一个问题。以下是引用代码:

import java.math.BigInteger;
import java.util.Arrays;

public class FibonacciNumbersB {

    static BigInteger[] dp = new BigInteger[10000];

    public static void main(String[] args) {
        Arrays.fill(dp, BigInteger.ZERO);
        dp[0] = BigInteger.ONE;
        dp[1] = BigInteger.ONE;

        for(int i = 4; i < 9999; i++)
            System.out.println(fibRecurse(i).toString());
    }

    public static BigInteger fibRecurse(int N) {
        for(int i = 2; i < N; i++) {
            // For numerous calls to this function, this will save as it goes
            if(dp[i].equals(BigInteger.ZERO))
                dp[i] = dp[i - 1].add(dp[i - 2]);
        }

        return dp[N - 1];
    }
}

我在 fibRecurse 方法中有一个语句检查 dp[i] 是否等于 0(尽管 fibRecurse不是递归的)。

检查 dp[i] 是否已被计算或让 dp[i] 等于前两个元素的总和是否更有效？

Answer 1

我更喜欢 Map<Integer, BigInteger>在使用固定 BigInteger[]在执行此内存时。请注意，您当前的方法不是递归。 Map可以像这样声明和初始化

static Map<Integer, BigInteger> memo = new HashMap<>();
static {
    memo.put(0, BigInteger.ONE);
    memo.put(1, BigInteger.ONE);
}

然后检查当前n是否存在于 memo 中(如果是，则返回)-否则，计算机并存储它。喜欢，

public static BigInteger fibRecurse(int n) {
    if (memo.containsKey(n)) {
        return memo.get(n);
    }
    BigInteger v = fibRecurse(n - 1).add(fibRecurse(n - 2));
    memo.put(n, v);
    return v;
}

没有内存 的版本会简单地省略 memo喜欢

public static BigInteger fibRecurseSlow(int n) {
    if (n == 0 || n == 1) return BigInteger.ONE;
    BigInteger v = fibRecurse(n - 1).add(fibRecurse(n - 2));
    return v;
}

我认为您可以从我选择的方法名称中推断哪个速度较慢。